1 // Copyright 2015-2023 The Khronos Group Inc.
2 //
3 // SPDX-License-Identifier: Apache-2.0 OR MIT
4 //
5 
6 // This header is generated from the Khronos Vulkan XML API Registry.
7 
8 #ifndef VULKAN_TO_STRING_HPP
9 #  define VULKAN_TO_STRING_HPP
10 
11 #include <vulkan/vulkansc_enums.hpp>
12 
13 #if __cpp_lib_format
14 #  include <format>   // std::format
15 #else
16 #  include <sstream>  // std::stringstream
17 #endif
18 
19 namespace VULKAN_HPP_NAMESPACE
20 {
21 
22   //==========================
23   //=== BITMASKs to_string ===
24   //==========================
25 
26 
27   //=== VK_VERSION_1_0 ===
28 
to_string(FormatFeatureFlags value)29   VULKAN_HPP_INLINE std::string to_string( FormatFeatureFlags value )
30   {
31     if ( !value )
32       return "{}";
33 
34     std::string result;
35     if ( value & FormatFeatureFlagBits::eSampledImage ) result += "SampledImage | ";
36     if ( value & FormatFeatureFlagBits::eStorageImage ) result += "StorageImage | ";
37     if ( value & FormatFeatureFlagBits::eStorageImageAtomic ) result += "StorageImageAtomic | ";
38     if ( value & FormatFeatureFlagBits::eUniformTexelBuffer ) result += "UniformTexelBuffer | ";
39     if ( value & FormatFeatureFlagBits::eStorageTexelBuffer ) result += "StorageTexelBuffer | ";
40     if ( value & FormatFeatureFlagBits::eStorageTexelBufferAtomic ) result += "StorageTexelBufferAtomic | ";
41     if ( value & FormatFeatureFlagBits::eVertexBuffer ) result += "VertexBuffer | ";
42     if ( value & FormatFeatureFlagBits::eColorAttachment ) result += "ColorAttachment | ";
43     if ( value & FormatFeatureFlagBits::eColorAttachmentBlend ) result += "ColorAttachmentBlend | ";
44     if ( value & FormatFeatureFlagBits::eDepthStencilAttachment ) result += "DepthStencilAttachment | ";
45     if ( value & FormatFeatureFlagBits::eBlitSrc ) result += "BlitSrc | ";
46     if ( value & FormatFeatureFlagBits::eBlitDst ) result += "BlitDst | ";
47     if ( value & FormatFeatureFlagBits::eSampledImageFilterLinear ) result += "SampledImageFilterLinear | ";
48     if ( value & FormatFeatureFlagBits::eTransferSrc ) result += "TransferSrc | ";
49     if ( value & FormatFeatureFlagBits::eTransferDst ) result += "TransferDst | ";
50     if ( value & FormatFeatureFlagBits::eMidpointChromaSamples ) result += "MidpointChromaSamples | ";
51     if ( value & FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter ) result += "SampledImageYcbcrConversionLinearFilter | ";
52     if ( value & FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter ) result += "SampledImageYcbcrConversionSeparateReconstructionFilter | ";
53     if ( value & FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit ) result += "SampledImageYcbcrConversionChromaReconstructionExplicit | ";
54     if ( value & FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable ) result += "SampledImageYcbcrConversionChromaReconstructionExplicitForceable | ";
55     if ( value & FormatFeatureFlagBits::eDisjoint ) result += "Disjoint | ";
56     if ( value & FormatFeatureFlagBits::eCositedChromaSamples ) result += "CositedChromaSamples | ";
57     if ( value & FormatFeatureFlagBits::eSampledImageFilterMinmax ) result += "SampledImageFilterMinmax | ";
58     if ( value & FormatFeatureFlagBits::eSampledImageFilterCubicEXT ) result += "SampledImageFilterCubicEXT | ";
59     if ( value & FormatFeatureFlagBits::eFragmentShadingRateAttachmentKHR ) result += "FragmentShadingRateAttachmentKHR | ";
60 
61     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
62   }
63 
to_string(ImageCreateFlags value)64   VULKAN_HPP_INLINE std::string to_string( ImageCreateFlags value )
65   {
66     if ( !value )
67       return "{}";
68 
69     std::string result;
70     if ( value & ImageCreateFlagBits::eSparseBinding ) result += "SparseBinding | ";
71     if ( value & ImageCreateFlagBits::eSparseResidency ) result += "SparseResidency | ";
72     if ( value & ImageCreateFlagBits::eSparseAliased ) result += "SparseAliased | ";
73     if ( value & ImageCreateFlagBits::eMutableFormat ) result += "MutableFormat | ";
74     if ( value & ImageCreateFlagBits::eCubeCompatible ) result += "CubeCompatible | ";
75     if ( value & ImageCreateFlagBits::eAlias ) result += "Alias | ";
76     if ( value & ImageCreateFlagBits::eSplitInstanceBindRegions ) result += "SplitInstanceBindRegions | ";
77     if ( value & ImageCreateFlagBits::e2DArrayCompatible ) result += "2DArrayCompatible | ";
78     if ( value & ImageCreateFlagBits::eBlockTexelViewCompatible ) result += "BlockTexelViewCompatible | ";
79     if ( value & ImageCreateFlagBits::eExtendedUsage ) result += "ExtendedUsage | ";
80     if ( value & ImageCreateFlagBits::eProtected ) result += "Protected | ";
81     if ( value & ImageCreateFlagBits::eDisjoint ) result += "Disjoint | ";
82     if ( value & ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT ) result += "SampleLocationsCompatibleDepthEXT | ";
83 
84     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
85   }
86 
to_string(ImageUsageFlags value)87   VULKAN_HPP_INLINE std::string to_string( ImageUsageFlags value )
88   {
89     if ( !value )
90       return "{}";
91 
92     std::string result;
93     if ( value & ImageUsageFlagBits::eTransferSrc ) result += "TransferSrc | ";
94     if ( value & ImageUsageFlagBits::eTransferDst ) result += "TransferDst | ";
95     if ( value & ImageUsageFlagBits::eSampled ) result += "Sampled | ";
96     if ( value & ImageUsageFlagBits::eStorage ) result += "Storage | ";
97     if ( value & ImageUsageFlagBits::eColorAttachment ) result += "ColorAttachment | ";
98     if ( value & ImageUsageFlagBits::eDepthStencilAttachment ) result += "DepthStencilAttachment | ";
99     if ( value & ImageUsageFlagBits::eTransientAttachment ) result += "TransientAttachment | ";
100     if ( value & ImageUsageFlagBits::eInputAttachment ) result += "InputAttachment | ";
101     if ( value & ImageUsageFlagBits::eFragmentShadingRateAttachmentKHR ) result += "FragmentShadingRateAttachmentKHR | ";
102 
103     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
104   }
105 
to_string(InstanceCreateFlags)106   VULKAN_HPP_INLINE std::string to_string( InstanceCreateFlags )
107   {
108     return "{}";
109   }
110 
to_string(MemoryHeapFlags value)111   VULKAN_HPP_INLINE std::string to_string( MemoryHeapFlags value )
112   {
113     if ( !value )
114       return "{}";
115 
116     std::string result;
117     if ( value & MemoryHeapFlagBits::eDeviceLocal ) result += "DeviceLocal | ";
118     if ( value & MemoryHeapFlagBits::eMultiInstance ) result += "MultiInstance | ";
119     if ( value & MemoryHeapFlagBits::eSeuSafe ) result += "SeuSafe | ";
120 
121     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
122   }
123 
to_string(MemoryPropertyFlags value)124   VULKAN_HPP_INLINE std::string to_string( MemoryPropertyFlags value )
125   {
126     if ( !value )
127       return "{}";
128 
129     std::string result;
130     if ( value & MemoryPropertyFlagBits::eDeviceLocal ) result += "DeviceLocal | ";
131     if ( value & MemoryPropertyFlagBits::eHostVisible ) result += "HostVisible | ";
132     if ( value & MemoryPropertyFlagBits::eHostCoherent ) result += "HostCoherent | ";
133     if ( value & MemoryPropertyFlagBits::eHostCached ) result += "HostCached | ";
134     if ( value & MemoryPropertyFlagBits::eLazilyAllocated ) result += "LazilyAllocated | ";
135     if ( value & MemoryPropertyFlagBits::eProtected ) result += "Protected | ";
136 
137     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
138   }
139 
to_string(QueueFlags value)140   VULKAN_HPP_INLINE std::string to_string( QueueFlags value )
141   {
142     if ( !value )
143       return "{}";
144 
145     std::string result;
146     if ( value & QueueFlagBits::eGraphics ) result += "Graphics | ";
147     if ( value & QueueFlagBits::eCompute ) result += "Compute | ";
148     if ( value & QueueFlagBits::eTransfer ) result += "Transfer | ";
149     if ( value & QueueFlagBits::eProtected ) result += "Protected | ";
150 
151     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
152   }
153 
to_string(SampleCountFlags value)154   VULKAN_HPP_INLINE std::string to_string( SampleCountFlags value )
155   {
156     if ( !value )
157       return "{}";
158 
159     std::string result;
160     if ( value & SampleCountFlagBits::e1 ) result += "1 | ";
161     if ( value & SampleCountFlagBits::e2 ) result += "2 | ";
162     if ( value & SampleCountFlagBits::e4 ) result += "4 | ";
163     if ( value & SampleCountFlagBits::e8 ) result += "8 | ";
164     if ( value & SampleCountFlagBits::e16 ) result += "16 | ";
165     if ( value & SampleCountFlagBits::e32 ) result += "32 | ";
166     if ( value & SampleCountFlagBits::e64 ) result += "64 | ";
167 
168     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
169   }
170 
to_string(DeviceCreateFlags)171   VULKAN_HPP_INLINE std::string to_string( DeviceCreateFlags )
172   {
173     return "{}";
174   }
175 
to_string(DeviceQueueCreateFlags value)176   VULKAN_HPP_INLINE std::string to_string( DeviceQueueCreateFlags value )
177   {
178     if ( !value )
179       return "{}";
180 
181     std::string result;
182     if ( value & DeviceQueueCreateFlagBits::eProtected ) result += "Protected | ";
183 
184     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
185   }
186 
to_string(PipelineStageFlags value)187   VULKAN_HPP_INLINE std::string to_string( PipelineStageFlags value )
188   {
189     if ( !value )
190       return "None";
191 
192     std::string result;
193     if ( value & PipelineStageFlagBits::eTopOfPipe ) result += "TopOfPipe | ";
194     if ( value & PipelineStageFlagBits::eDrawIndirect ) result += "DrawIndirect | ";
195     if ( value & PipelineStageFlagBits::eVertexInput ) result += "VertexInput | ";
196     if ( value & PipelineStageFlagBits::eVertexShader ) result += "VertexShader | ";
197     if ( value & PipelineStageFlagBits::eTessellationControlShader ) result += "TessellationControlShader | ";
198     if ( value & PipelineStageFlagBits::eTessellationEvaluationShader ) result += "TessellationEvaluationShader | ";
199     if ( value & PipelineStageFlagBits::eGeometryShader ) result += "GeometryShader | ";
200     if ( value & PipelineStageFlagBits::eFragmentShader ) result += "FragmentShader | ";
201     if ( value & PipelineStageFlagBits::eEarlyFragmentTests ) result += "EarlyFragmentTests | ";
202     if ( value & PipelineStageFlagBits::eLateFragmentTests ) result += "LateFragmentTests | ";
203     if ( value & PipelineStageFlagBits::eColorAttachmentOutput ) result += "ColorAttachmentOutput | ";
204     if ( value & PipelineStageFlagBits::eComputeShader ) result += "ComputeShader | ";
205     if ( value & PipelineStageFlagBits::eTransfer ) result += "Transfer | ";
206     if ( value & PipelineStageFlagBits::eBottomOfPipe ) result += "BottomOfPipe | ";
207     if ( value & PipelineStageFlagBits::eHost ) result += "Host | ";
208     if ( value & PipelineStageFlagBits::eAllGraphics ) result += "AllGraphics | ";
209     if ( value & PipelineStageFlagBits::eAllCommands ) result += "AllCommands | ";
210     if ( value & PipelineStageFlagBits::eFragmentShadingRateAttachmentKHR ) result += "FragmentShadingRateAttachmentKHR | ";
211 
212     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
213   }
214 
to_string(MemoryMapFlags)215   VULKAN_HPP_INLINE std::string to_string( MemoryMapFlags )
216   {
217     return "{}";
218   }
219 
to_string(ImageAspectFlags value)220   VULKAN_HPP_INLINE std::string to_string( ImageAspectFlags value )
221   {
222     if ( !value )
223       return "None";
224 
225     std::string result;
226     if ( value & ImageAspectFlagBits::eColor ) result += "Color | ";
227     if ( value & ImageAspectFlagBits::eDepth ) result += "Depth | ";
228     if ( value & ImageAspectFlagBits::eStencil ) result += "Stencil | ";
229     if ( value & ImageAspectFlagBits::eMetadata ) result += "Metadata | ";
230     if ( value & ImageAspectFlagBits::ePlane0 ) result += "Plane0 | ";
231     if ( value & ImageAspectFlagBits::ePlane1 ) result += "Plane1 | ";
232     if ( value & ImageAspectFlagBits::ePlane2 ) result += "Plane2 | ";
233     if ( value & ImageAspectFlagBits::eMemoryPlane0EXT ) result += "MemoryPlane0EXT | ";
234     if ( value & ImageAspectFlagBits::eMemoryPlane1EXT ) result += "MemoryPlane1EXT | ";
235     if ( value & ImageAspectFlagBits::eMemoryPlane2EXT ) result += "MemoryPlane2EXT | ";
236     if ( value & ImageAspectFlagBits::eMemoryPlane3EXT ) result += "MemoryPlane3EXT | ";
237 
238     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
239   }
240 
to_string(FenceCreateFlags value)241   VULKAN_HPP_INLINE std::string to_string( FenceCreateFlags value )
242   {
243     if ( !value )
244       return "{}";
245 
246     std::string result;
247     if ( value & FenceCreateFlagBits::eSignaled ) result += "Signaled | ";
248 
249     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
250   }
251 
to_string(SemaphoreCreateFlags)252   VULKAN_HPP_INLINE std::string to_string( SemaphoreCreateFlags )
253   {
254     return "{}";
255   }
256 
to_string(EventCreateFlags value)257   VULKAN_HPP_INLINE std::string to_string( EventCreateFlags value )
258   {
259     if ( !value )
260       return "{}";
261 
262     std::string result;
263     if ( value & EventCreateFlagBits::eDeviceOnly ) result += "DeviceOnly | ";
264 
265     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
266   }
267 
to_string(QueryPipelineStatisticFlags value)268   VULKAN_HPP_INLINE std::string to_string( QueryPipelineStatisticFlags value )
269   {
270     if ( !value )
271       return "{}";
272 
273     std::string result;
274     if ( value & QueryPipelineStatisticFlagBits::eInputAssemblyVertices ) result += "InputAssemblyVertices | ";
275     if ( value & QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives ) result += "InputAssemblyPrimitives | ";
276     if ( value & QueryPipelineStatisticFlagBits::eVertexShaderInvocations ) result += "VertexShaderInvocations | ";
277     if ( value & QueryPipelineStatisticFlagBits::eGeometryShaderInvocations ) result += "GeometryShaderInvocations | ";
278     if ( value & QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives ) result += "GeometryShaderPrimitives | ";
279     if ( value & QueryPipelineStatisticFlagBits::eClippingInvocations ) result += "ClippingInvocations | ";
280     if ( value & QueryPipelineStatisticFlagBits::eClippingPrimitives ) result += "ClippingPrimitives | ";
281     if ( value & QueryPipelineStatisticFlagBits::eFragmentShaderInvocations ) result += "FragmentShaderInvocations | ";
282     if ( value & QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches ) result += "TessellationControlShaderPatches | ";
283     if ( value & QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations ) result += "TessellationEvaluationShaderInvocations | ";
284     if ( value & QueryPipelineStatisticFlagBits::eComputeShaderInvocations ) result += "ComputeShaderInvocations | ";
285 
286     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
287   }
288 
to_string(QueryPoolCreateFlags)289   VULKAN_HPP_INLINE std::string to_string( QueryPoolCreateFlags )
290   {
291     return "{}";
292   }
293 
to_string(QueryResultFlags value)294   VULKAN_HPP_INLINE std::string to_string( QueryResultFlags value )
295   {
296     if ( !value )
297       return "{}";
298 
299     std::string result;
300     if ( value & QueryResultFlagBits::e64 ) result += "64 | ";
301     if ( value & QueryResultFlagBits::eWait ) result += "Wait | ";
302     if ( value & QueryResultFlagBits::eWithAvailability ) result += "WithAvailability | ";
303     if ( value & QueryResultFlagBits::ePartial ) result += "Partial | ";
304 
305     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
306   }
307 
to_string(BufferCreateFlags value)308   VULKAN_HPP_INLINE std::string to_string( BufferCreateFlags value )
309   {
310     if ( !value )
311       return "{}";
312 
313     std::string result;
314     if ( value & BufferCreateFlagBits::eSparseBinding ) result += "SparseBinding | ";
315     if ( value & BufferCreateFlagBits::eSparseResidency ) result += "SparseResidency | ";
316     if ( value & BufferCreateFlagBits::eSparseAliased ) result += "SparseAliased | ";
317     if ( value & BufferCreateFlagBits::eProtected ) result += "Protected | ";
318     if ( value & BufferCreateFlagBits::eDeviceAddressCaptureReplay ) result += "DeviceAddressCaptureReplay | ";
319 
320     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
321   }
322 
to_string(BufferUsageFlags value)323   VULKAN_HPP_INLINE std::string to_string( BufferUsageFlags value )
324   {
325     if ( !value )
326       return "{}";
327 
328     std::string result;
329     if ( value & BufferUsageFlagBits::eTransferSrc ) result += "TransferSrc | ";
330     if ( value & BufferUsageFlagBits::eTransferDst ) result += "TransferDst | ";
331     if ( value & BufferUsageFlagBits::eUniformTexelBuffer ) result += "UniformTexelBuffer | ";
332     if ( value & BufferUsageFlagBits::eStorageTexelBuffer ) result += "StorageTexelBuffer | ";
333     if ( value & BufferUsageFlagBits::eUniformBuffer ) result += "UniformBuffer | ";
334     if ( value & BufferUsageFlagBits::eStorageBuffer ) result += "StorageBuffer | ";
335     if ( value & BufferUsageFlagBits::eIndexBuffer ) result += "IndexBuffer | ";
336     if ( value & BufferUsageFlagBits::eVertexBuffer ) result += "VertexBuffer | ";
337     if ( value & BufferUsageFlagBits::eIndirectBuffer ) result += "IndirectBuffer | ";
338     if ( value & BufferUsageFlagBits::eShaderDeviceAddress ) result += "ShaderDeviceAddress | ";
339 
340     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
341   }
342 
to_string(BufferViewCreateFlags)343   VULKAN_HPP_INLINE std::string to_string( BufferViewCreateFlags )
344   {
345     return "{}";
346   }
347 
to_string(ImageViewCreateFlags)348   VULKAN_HPP_INLINE std::string to_string( ImageViewCreateFlags )
349   {
350     return "{}";
351   }
352 
to_string(PipelineCacheCreateFlags value)353   VULKAN_HPP_INLINE std::string to_string( PipelineCacheCreateFlags value )
354   {
355     if ( !value )
356       return "{}";
357 
358     std::string result;
359     if ( value & PipelineCacheCreateFlagBits::eExternallySynchronized ) result += "ExternallySynchronized | ";
360     if ( value & PipelineCacheCreateFlagBits::eReadOnly ) result += "ReadOnly | ";
361     if ( value & PipelineCacheCreateFlagBits::eUseApplicationStorage ) result += "UseApplicationStorage | ";
362 
363     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
364   }
365 
to_string(ColorComponentFlags value)366   VULKAN_HPP_INLINE std::string to_string( ColorComponentFlags value )
367   {
368     if ( !value )
369       return "{}";
370 
371     std::string result;
372     if ( value & ColorComponentFlagBits::eR ) result += "R | ";
373     if ( value & ColorComponentFlagBits::eG ) result += "G | ";
374     if ( value & ColorComponentFlagBits::eB ) result += "B | ";
375     if ( value & ColorComponentFlagBits::eA ) result += "A | ";
376 
377     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
378   }
379 
to_string(CullModeFlags value)380   VULKAN_HPP_INLINE std::string to_string( CullModeFlags value )
381   {
382     if ( !value )
383       return "None";
384 
385     std::string result;
386     if ( value & CullModeFlagBits::eFront ) result += "Front | ";
387     if ( value & CullModeFlagBits::eBack ) result += "Back | ";
388 
389     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
390   }
391 
to_string(PipelineColorBlendStateCreateFlags)392   VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlags )
393   {
394     return "{}";
395   }
396 
to_string(PipelineCreateFlags value)397   VULKAN_HPP_INLINE std::string to_string( PipelineCreateFlags value )
398   {
399     if ( !value )
400       return "{}";
401 
402     std::string result;
403     if ( value & PipelineCreateFlagBits::eDisableOptimization ) result += "DisableOptimization | ";
404     if ( value & PipelineCreateFlagBits::eViewIndexFromDeviceIndex ) result += "ViewIndexFromDeviceIndex | ";
405     if ( value & PipelineCreateFlagBits::eDispatchBase ) result += "DispatchBase | ";
406     if ( value & PipelineCreateFlagBits::eFailOnPipelineCompileRequired ) result += "FailOnPipelineCompileRequired | ";
407     if ( value & PipelineCreateFlagBits::eEarlyReturnOnFailure ) result += "EarlyReturnOnFailure | ";
408 
409     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
410   }
411 
to_string(PipelineDepthStencilStateCreateFlags)412   VULKAN_HPP_INLINE std::string to_string( PipelineDepthStencilStateCreateFlags )
413   {
414     return "{}";
415   }
416 
to_string(PipelineDynamicStateCreateFlags)417   VULKAN_HPP_INLINE std::string to_string( PipelineDynamicStateCreateFlags )
418   {
419     return "{}";
420   }
421 
to_string(PipelineInputAssemblyStateCreateFlags)422   VULKAN_HPP_INLINE std::string to_string( PipelineInputAssemblyStateCreateFlags )
423   {
424     return "{}";
425   }
426 
to_string(PipelineLayoutCreateFlags)427   VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlags )
428   {
429     return "{}";
430   }
431 
to_string(PipelineMultisampleStateCreateFlags)432   VULKAN_HPP_INLINE std::string to_string( PipelineMultisampleStateCreateFlags )
433   {
434     return "{}";
435   }
436 
to_string(PipelineRasterizationStateCreateFlags)437   VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateCreateFlags )
438   {
439     return "{}";
440   }
441 
to_string(PipelineShaderStageCreateFlags value)442   VULKAN_HPP_INLINE std::string to_string( PipelineShaderStageCreateFlags value )
443   {
444     if ( !value )
445       return "{}";
446 
447     std::string result;
448     if ( value & PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSize ) result += "AllowVaryingSubgroupSize | ";
449     if ( value & PipelineShaderStageCreateFlagBits::eRequireFullSubgroups ) result += "RequireFullSubgroups | ";
450 
451     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
452   }
453 
to_string(PipelineTessellationStateCreateFlags)454   VULKAN_HPP_INLINE std::string to_string( PipelineTessellationStateCreateFlags )
455   {
456     return "{}";
457   }
458 
to_string(PipelineVertexInputStateCreateFlags)459   VULKAN_HPP_INLINE std::string to_string( PipelineVertexInputStateCreateFlags )
460   {
461     return "{}";
462   }
463 
to_string(PipelineViewportStateCreateFlags)464   VULKAN_HPP_INLINE std::string to_string( PipelineViewportStateCreateFlags )
465   {
466     return "{}";
467   }
468 
to_string(ShaderStageFlags value)469   VULKAN_HPP_INLINE std::string to_string( ShaderStageFlags value )
470   {
471     if ( !value )
472       return "{}";
473 
474     std::string result;
475     if ( value & ShaderStageFlagBits::eVertex ) result += "Vertex | ";
476     if ( value & ShaderStageFlagBits::eTessellationControl ) result += "TessellationControl | ";
477     if ( value & ShaderStageFlagBits::eTessellationEvaluation ) result += "TessellationEvaluation | ";
478     if ( value & ShaderStageFlagBits::eGeometry ) result += "Geometry | ";
479     if ( value & ShaderStageFlagBits::eFragment ) result += "Fragment | ";
480     if ( value & ShaderStageFlagBits::eCompute ) result += "Compute | ";
481 
482     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
483   }
484 
to_string(SamplerCreateFlags)485   VULKAN_HPP_INLINE std::string to_string( SamplerCreateFlags )
486   {
487     return "{}";
488   }
489 
to_string(DescriptorPoolCreateFlags value)490   VULKAN_HPP_INLINE std::string to_string( DescriptorPoolCreateFlags value )
491   {
492     if ( !value )
493       return "{}";
494 
495     std::string result;
496     if ( value & DescriptorPoolCreateFlagBits::eFreeDescriptorSet ) result += "FreeDescriptorSet | ";
497     if ( value & DescriptorPoolCreateFlagBits::eUpdateAfterBind ) result += "UpdateAfterBind | ";
498 
499     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
500   }
501 
to_string(DescriptorPoolResetFlags)502   VULKAN_HPP_INLINE std::string to_string( DescriptorPoolResetFlags )
503   {
504     return "{}";
505   }
506 
to_string(DescriptorSetLayoutCreateFlags value)507   VULKAN_HPP_INLINE std::string to_string( DescriptorSetLayoutCreateFlags value )
508   {
509     if ( !value )
510       return "{}";
511 
512     std::string result;
513     if ( value & DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool ) result += "UpdateAfterBindPool | ";
514 
515     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
516   }
517 
to_string(AccessFlags value)518   VULKAN_HPP_INLINE std::string to_string( AccessFlags value )
519   {
520     if ( !value )
521       return "None";
522 
523     std::string result;
524     if ( value & AccessFlagBits::eIndirectCommandRead ) result += "IndirectCommandRead | ";
525     if ( value & AccessFlagBits::eIndexRead ) result += "IndexRead | ";
526     if ( value & AccessFlagBits::eVertexAttributeRead ) result += "VertexAttributeRead | ";
527     if ( value & AccessFlagBits::eUniformRead ) result += "UniformRead | ";
528     if ( value & AccessFlagBits::eInputAttachmentRead ) result += "InputAttachmentRead | ";
529     if ( value & AccessFlagBits::eShaderRead ) result += "ShaderRead | ";
530     if ( value & AccessFlagBits::eShaderWrite ) result += "ShaderWrite | ";
531     if ( value & AccessFlagBits::eColorAttachmentRead ) result += "ColorAttachmentRead | ";
532     if ( value & AccessFlagBits::eColorAttachmentWrite ) result += "ColorAttachmentWrite | ";
533     if ( value & AccessFlagBits::eDepthStencilAttachmentRead ) result += "DepthStencilAttachmentRead | ";
534     if ( value & AccessFlagBits::eDepthStencilAttachmentWrite ) result += "DepthStencilAttachmentWrite | ";
535     if ( value & AccessFlagBits::eTransferRead ) result += "TransferRead | ";
536     if ( value & AccessFlagBits::eTransferWrite ) result += "TransferWrite | ";
537     if ( value & AccessFlagBits::eHostRead ) result += "HostRead | ";
538     if ( value & AccessFlagBits::eHostWrite ) result += "HostWrite | ";
539     if ( value & AccessFlagBits::eMemoryRead ) result += "MemoryRead | ";
540     if ( value & AccessFlagBits::eMemoryWrite ) result += "MemoryWrite | ";
541     if ( value & AccessFlagBits::eColorAttachmentReadNoncoherentEXT ) result += "ColorAttachmentReadNoncoherentEXT | ";
542     if ( value & AccessFlagBits::eFragmentShadingRateAttachmentReadKHR ) result += "FragmentShadingRateAttachmentReadKHR | ";
543 
544     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
545   }
546 
to_string(AttachmentDescriptionFlags value)547   VULKAN_HPP_INLINE std::string to_string( AttachmentDescriptionFlags value )
548   {
549     if ( !value )
550       return "{}";
551 
552     std::string result;
553     if ( value & AttachmentDescriptionFlagBits::eMayAlias ) result += "MayAlias | ";
554 
555     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
556   }
557 
to_string(DependencyFlags value)558   VULKAN_HPP_INLINE std::string to_string( DependencyFlags value )
559   {
560     if ( !value )
561       return "{}";
562 
563     std::string result;
564     if ( value & DependencyFlagBits::eByRegion ) result += "ByRegion | ";
565     if ( value & DependencyFlagBits::eDeviceGroup ) result += "DeviceGroup | ";
566     if ( value & DependencyFlagBits::eViewLocal ) result += "ViewLocal | ";
567 
568     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
569   }
570 
to_string(FramebufferCreateFlags value)571   VULKAN_HPP_INLINE std::string to_string( FramebufferCreateFlags value )
572   {
573     if ( !value )
574       return "{}";
575 
576     std::string result;
577     if ( value & FramebufferCreateFlagBits::eImageless ) result += "Imageless | ";
578 
579     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
580   }
581 
to_string(RenderPassCreateFlags)582   VULKAN_HPP_INLINE std::string to_string( RenderPassCreateFlags )
583   {
584     return "{}";
585   }
586 
to_string(SubpassDescriptionFlags)587   VULKAN_HPP_INLINE std::string to_string( SubpassDescriptionFlags )
588   {
589     return "{}";
590   }
591 
to_string(CommandPoolCreateFlags value)592   VULKAN_HPP_INLINE std::string to_string( CommandPoolCreateFlags value )
593   {
594     if ( !value )
595       return "{}";
596 
597     std::string result;
598     if ( value & CommandPoolCreateFlagBits::eTransient ) result += "Transient | ";
599     if ( value & CommandPoolCreateFlagBits::eResetCommandBuffer ) result += "ResetCommandBuffer | ";
600     if ( value & CommandPoolCreateFlagBits::eProtected ) result += "Protected | ";
601 
602     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
603   }
604 
to_string(CommandPoolResetFlags)605   VULKAN_HPP_INLINE std::string to_string( CommandPoolResetFlags )
606   {
607     return "{}";
608   }
609 
to_string(CommandBufferResetFlags value)610   VULKAN_HPP_INLINE std::string to_string( CommandBufferResetFlags value )
611   {
612     if ( !value )
613       return "{}";
614 
615     std::string result;
616     if ( value & CommandBufferResetFlagBits::eReleaseResources ) result += "ReleaseResources | ";
617 
618     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
619   }
620 
to_string(CommandBufferUsageFlags value)621   VULKAN_HPP_INLINE std::string to_string( CommandBufferUsageFlags value )
622   {
623     if ( !value )
624       return "{}";
625 
626     std::string result;
627     if ( value & CommandBufferUsageFlagBits::eOneTimeSubmit ) result += "OneTimeSubmit | ";
628     if ( value & CommandBufferUsageFlagBits::eRenderPassContinue ) result += "RenderPassContinue | ";
629     if ( value & CommandBufferUsageFlagBits::eSimultaneousUse ) result += "SimultaneousUse | ";
630 
631     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
632   }
633 
to_string(QueryControlFlags value)634   VULKAN_HPP_INLINE std::string to_string( QueryControlFlags value )
635   {
636     if ( !value )
637       return "{}";
638 
639     std::string result;
640     if ( value & QueryControlFlagBits::ePrecise ) result += "Precise | ";
641 
642     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
643   }
644 
to_string(StencilFaceFlags value)645   VULKAN_HPP_INLINE std::string to_string( StencilFaceFlags value )
646   {
647     if ( !value )
648       return "{}";
649 
650     std::string result;
651     if ( value & StencilFaceFlagBits::eFront ) result += "Front | ";
652     if ( value & StencilFaceFlagBits::eBack ) result += "Back | ";
653 
654     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
655   }
656 
657   //=== VK_VERSION_1_1 ===
658 
to_string(SubgroupFeatureFlags value)659   VULKAN_HPP_INLINE std::string to_string( SubgroupFeatureFlags value )
660   {
661     if ( !value )
662       return "{}";
663 
664     std::string result;
665     if ( value & SubgroupFeatureFlagBits::eBasic ) result += "Basic | ";
666     if ( value & SubgroupFeatureFlagBits::eVote ) result += "Vote | ";
667     if ( value & SubgroupFeatureFlagBits::eArithmetic ) result += "Arithmetic | ";
668     if ( value & SubgroupFeatureFlagBits::eBallot ) result += "Ballot | ";
669     if ( value & SubgroupFeatureFlagBits::eShuffle ) result += "Shuffle | ";
670     if ( value & SubgroupFeatureFlagBits::eShuffleRelative ) result += "ShuffleRelative | ";
671     if ( value & SubgroupFeatureFlagBits::eClustered ) result += "Clustered | ";
672     if ( value & SubgroupFeatureFlagBits::eQuad ) result += "Quad | ";
673 
674     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
675   }
676 
to_string(PeerMemoryFeatureFlags value)677   VULKAN_HPP_INLINE std::string to_string( PeerMemoryFeatureFlags value )
678   {
679     if ( !value )
680       return "{}";
681 
682     std::string result;
683     if ( value & PeerMemoryFeatureFlagBits::eCopySrc ) result += "CopySrc | ";
684     if ( value & PeerMemoryFeatureFlagBits::eCopyDst ) result += "CopyDst | ";
685     if ( value & PeerMemoryFeatureFlagBits::eGenericSrc ) result += "GenericSrc | ";
686     if ( value & PeerMemoryFeatureFlagBits::eGenericDst ) result += "GenericDst | ";
687 
688     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
689   }
690 
to_string(MemoryAllocateFlags value)691   VULKAN_HPP_INLINE std::string to_string( MemoryAllocateFlags value )
692   {
693     if ( !value )
694       return "{}";
695 
696     std::string result;
697     if ( value & MemoryAllocateFlagBits::eDeviceMask ) result += "DeviceMask | ";
698     if ( value & MemoryAllocateFlagBits::eDeviceAddress ) result += "DeviceAddress | ";
699     if ( value & MemoryAllocateFlagBits::eDeviceAddressCaptureReplay ) result += "DeviceAddressCaptureReplay | ";
700 
701     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
702   }
703 
to_string(ExternalMemoryHandleTypeFlags value)704   VULKAN_HPP_INLINE std::string to_string( ExternalMemoryHandleTypeFlags value )
705   {
706     if ( !value )
707       return "{}";
708 
709     std::string result;
710     if ( value & ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) result += "OpaqueFd | ";
711     if ( value & ExternalMemoryHandleTypeFlagBits::eOpaqueWin32 ) result += "OpaqueWin32 | ";
712     if ( value & ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt ) result += "OpaqueWin32Kmt | ";
713     if ( value & ExternalMemoryHandleTypeFlagBits::eD3D11Texture ) result += "D3D11Texture | ";
714     if ( value & ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt ) result += "D3D11TextureKmt | ";
715     if ( value & ExternalMemoryHandleTypeFlagBits::eD3D12Heap ) result += "D3D12Heap | ";
716     if ( value & ExternalMemoryHandleTypeFlagBits::eD3D12Resource ) result += "D3D12Resource | ";
717     if ( value & ExternalMemoryHandleTypeFlagBits::eDmaBufEXT ) result += "DmaBufEXT | ";
718     if ( value & ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT ) result += "HostAllocationEXT | ";
719     if ( value & ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT ) result += "HostMappedForeignMemoryEXT | ";
720 #if defined( VK_USE_PLATFORM_SCI )
721     if ( value & ExternalMemoryHandleTypeFlagBits::eSciBufNV ) result += "SciBufNV | ";
722 #endif /*VK_USE_PLATFORM_SCI*/
723 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
724     if ( value & ExternalMemoryHandleTypeFlagBits::eScreenBufferQNX ) result += "ScreenBufferQNX | ";
725 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
726 
727     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
728   }
729 
to_string(ExternalMemoryFeatureFlags value)730   VULKAN_HPP_INLINE std::string to_string( ExternalMemoryFeatureFlags value )
731   {
732     if ( !value )
733       return "{}";
734 
735     std::string result;
736     if ( value & ExternalMemoryFeatureFlagBits::eDedicatedOnly ) result += "DedicatedOnly | ";
737     if ( value & ExternalMemoryFeatureFlagBits::eExportable ) result += "Exportable | ";
738     if ( value & ExternalMemoryFeatureFlagBits::eImportable ) result += "Importable | ";
739 
740     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
741   }
742 
to_string(ExternalFenceHandleTypeFlags value)743   VULKAN_HPP_INLINE std::string to_string( ExternalFenceHandleTypeFlags value )
744   {
745     if ( !value )
746       return "{}";
747 
748     std::string result;
749     if ( value & ExternalFenceHandleTypeFlagBits::eOpaqueFd ) result += "OpaqueFd | ";
750     if ( value & ExternalFenceHandleTypeFlagBits::eOpaqueWin32 ) result += "OpaqueWin32 | ";
751     if ( value & ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt ) result += "OpaqueWin32Kmt | ";
752     if ( value & ExternalFenceHandleTypeFlagBits::eSyncFd ) result += "SyncFd | ";
753 #if defined( VK_USE_PLATFORM_SCI )
754     if ( value & ExternalFenceHandleTypeFlagBits::eSciSyncObjNV ) result += "SciSyncObjNV | ";
755     if ( value & ExternalFenceHandleTypeFlagBits::eSciSyncFenceNV ) result += "SciSyncFenceNV | ";
756 #endif /*VK_USE_PLATFORM_SCI*/
757 
758     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
759   }
760 
to_string(ExternalFenceFeatureFlags value)761   VULKAN_HPP_INLINE std::string to_string( ExternalFenceFeatureFlags value )
762   {
763     if ( !value )
764       return "{}";
765 
766     std::string result;
767     if ( value & ExternalFenceFeatureFlagBits::eExportable ) result += "Exportable | ";
768     if ( value & ExternalFenceFeatureFlagBits::eImportable ) result += "Importable | ";
769 
770     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
771   }
772 
to_string(FenceImportFlags value)773   VULKAN_HPP_INLINE std::string to_string( FenceImportFlags value )
774   {
775     if ( !value )
776       return "{}";
777 
778     std::string result;
779     if ( value & FenceImportFlagBits::eTemporary ) result += "Temporary | ";
780 
781     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
782   }
783 
to_string(SemaphoreImportFlags value)784   VULKAN_HPP_INLINE std::string to_string( SemaphoreImportFlags value )
785   {
786     if ( !value )
787       return "{}";
788 
789     std::string result;
790     if ( value & SemaphoreImportFlagBits::eTemporary ) result += "Temporary | ";
791 
792     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
793   }
794 
to_string(ExternalSemaphoreHandleTypeFlags value)795   VULKAN_HPP_INLINE std::string to_string( ExternalSemaphoreHandleTypeFlags value )
796   {
797     if ( !value )
798       return "{}";
799 
800     std::string result;
801     if ( value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) result += "OpaqueFd | ";
802     if ( value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32 ) result += "OpaqueWin32 | ";
803     if ( value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt ) result += "OpaqueWin32Kmt | ";
804     if ( value & ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence ) result += "D3D12Fence | ";
805     if ( value & ExternalSemaphoreHandleTypeFlagBits::eSyncFd ) result += "SyncFd | ";
806 #if defined( VK_USE_PLATFORM_SCI )
807     if ( value & ExternalSemaphoreHandleTypeFlagBits::eSciSyncObjNV ) result += "SciSyncObjNV | ";
808 #endif /*VK_USE_PLATFORM_SCI*/
809 
810     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
811   }
812 
to_string(ExternalSemaphoreFeatureFlags value)813   VULKAN_HPP_INLINE std::string to_string( ExternalSemaphoreFeatureFlags value )
814   {
815     if ( !value )
816       return "{}";
817 
818     std::string result;
819     if ( value & ExternalSemaphoreFeatureFlagBits::eExportable ) result += "Exportable | ";
820     if ( value & ExternalSemaphoreFeatureFlagBits::eImportable ) result += "Importable | ";
821 
822     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
823   }
824 
825   //=== VK_VERSION_1_2 ===
826 
to_string(DescriptorBindingFlags value)827   VULKAN_HPP_INLINE std::string to_string( DescriptorBindingFlags value )
828   {
829     if ( !value )
830       return "{}";
831 
832     std::string result;
833     if ( value & DescriptorBindingFlagBits::eUpdateAfterBind ) result += "UpdateAfterBind | ";
834     if ( value & DescriptorBindingFlagBits::eUpdateUnusedWhilePending ) result += "UpdateUnusedWhilePending | ";
835     if ( value & DescriptorBindingFlagBits::ePartiallyBound ) result += "PartiallyBound | ";
836     if ( value & DescriptorBindingFlagBits::eVariableDescriptorCount ) result += "VariableDescriptorCount | ";
837 
838     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
839   }
840 
to_string(ResolveModeFlags value)841   VULKAN_HPP_INLINE std::string to_string( ResolveModeFlags value )
842   {
843     if ( !value )
844       return "None";
845 
846     std::string result;
847     if ( value & ResolveModeFlagBits::eSampleZero ) result += "SampleZero | ";
848     if ( value & ResolveModeFlagBits::eAverage ) result += "Average | ";
849     if ( value & ResolveModeFlagBits::eMin ) result += "Min | ";
850     if ( value & ResolveModeFlagBits::eMax ) result += "Max | ";
851 
852     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
853   }
854 
to_string(SemaphoreWaitFlags value)855   VULKAN_HPP_INLINE std::string to_string( SemaphoreWaitFlags value )
856   {
857     if ( !value )
858       return "{}";
859 
860     std::string result;
861     if ( value & SemaphoreWaitFlagBits::eAny ) result += "Any | ";
862 
863     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
864   }
865 
866   //=== VK_VERSION_1_3 ===
867 
to_string(PipelineCreationFeedbackFlags value)868   VULKAN_HPP_INLINE std::string to_string( PipelineCreationFeedbackFlags value )
869   {
870     if ( !value )
871       return "{}";
872 
873     std::string result;
874     if ( value & PipelineCreationFeedbackFlagBits::eValid ) result += "Valid | ";
875     if ( value & PipelineCreationFeedbackFlagBits::eApplicationPipelineCacheHit ) result += "ApplicationPipelineCacheHit | ";
876     if ( value & PipelineCreationFeedbackFlagBits::eBasePipelineAcceleration ) result += "BasePipelineAcceleration | ";
877 
878     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
879   }
880 
to_string(ToolPurposeFlags value)881   VULKAN_HPP_INLINE std::string to_string( ToolPurposeFlags value )
882   {
883     if ( !value )
884       return "{}";
885 
886     std::string result;
887     if ( value & ToolPurposeFlagBits::eValidation ) result += "Validation | ";
888     if ( value & ToolPurposeFlagBits::eProfiling ) result += "Profiling | ";
889     if ( value & ToolPurposeFlagBits::eTracing ) result += "Tracing | ";
890     if ( value & ToolPurposeFlagBits::eAdditionalFeatures ) result += "AdditionalFeatures | ";
891     if ( value & ToolPurposeFlagBits::eModifyingFeatures ) result += "ModifyingFeatures | ";
892 
893     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
894   }
895 
to_string(PrivateDataSlotCreateFlags)896   VULKAN_HPP_INLINE std::string to_string( PrivateDataSlotCreateFlags )
897   {
898     return "{}";
899   }
900 
to_string(PipelineStageFlags2 value)901   VULKAN_HPP_INLINE std::string to_string( PipelineStageFlags2 value )
902   {
903     if ( !value )
904       return "None";
905 
906     std::string result;
907     if ( value & PipelineStageFlagBits2::eTopOfPipe ) result += "TopOfPipe | ";
908     if ( value & PipelineStageFlagBits2::eDrawIndirect ) result += "DrawIndirect | ";
909     if ( value & PipelineStageFlagBits2::eVertexInput ) result += "VertexInput | ";
910     if ( value & PipelineStageFlagBits2::eVertexShader ) result += "VertexShader | ";
911     if ( value & PipelineStageFlagBits2::eTessellationControlShader ) result += "TessellationControlShader | ";
912     if ( value & PipelineStageFlagBits2::eTessellationEvaluationShader ) result += "TessellationEvaluationShader | ";
913     if ( value & PipelineStageFlagBits2::eGeometryShader ) result += "GeometryShader | ";
914     if ( value & PipelineStageFlagBits2::eFragmentShader ) result += "FragmentShader | ";
915     if ( value & PipelineStageFlagBits2::eEarlyFragmentTests ) result += "EarlyFragmentTests | ";
916     if ( value & PipelineStageFlagBits2::eLateFragmentTests ) result += "LateFragmentTests | ";
917     if ( value & PipelineStageFlagBits2::eColorAttachmentOutput ) result += "ColorAttachmentOutput | ";
918     if ( value & PipelineStageFlagBits2::eComputeShader ) result += "ComputeShader | ";
919     if ( value & PipelineStageFlagBits2::eAllTransfer ) result += "AllTransfer | ";
920     if ( value & PipelineStageFlagBits2::eBottomOfPipe ) result += "BottomOfPipe | ";
921     if ( value & PipelineStageFlagBits2::eHost ) result += "Host | ";
922     if ( value & PipelineStageFlagBits2::eAllGraphics ) result += "AllGraphics | ";
923     if ( value & PipelineStageFlagBits2::eAllCommands ) result += "AllCommands | ";
924     if ( value & PipelineStageFlagBits2::eCopy ) result += "Copy | ";
925     if ( value & PipelineStageFlagBits2::eResolve ) result += "Resolve | ";
926     if ( value & PipelineStageFlagBits2::eBlit ) result += "Blit | ";
927     if ( value & PipelineStageFlagBits2::eClear ) result += "Clear | ";
928     if ( value & PipelineStageFlagBits2::eIndexInput ) result += "IndexInput | ";
929     if ( value & PipelineStageFlagBits2::eVertexAttributeInput ) result += "VertexAttributeInput | ";
930     if ( value & PipelineStageFlagBits2::ePreRasterizationShaders ) result += "PreRasterizationShaders | ";
931     if ( value & PipelineStageFlagBits2::eTransformFeedbackEXT ) result += "TransformFeedbackEXT | ";
932     if ( value & PipelineStageFlagBits2::eConditionalRenderingEXT ) result += "ConditionalRenderingEXT | ";
933     if ( value & PipelineStageFlagBits2::eCommandPreprocessNV ) result += "CommandPreprocessNV | ";
934     if ( value & PipelineStageFlagBits2::eFragmentShadingRateAttachmentKHR ) result += "FragmentShadingRateAttachmentKHR | ";
935     if ( value & PipelineStageFlagBits2::eAccelerationStructureBuildKHR ) result += "AccelerationStructureBuildKHR | ";
936     if ( value & PipelineStageFlagBits2::eRayTracingShaderKHR ) result += "RayTracingShaderKHR | ";
937     if ( value & PipelineStageFlagBits2::eFragmentDensityProcessEXT ) result += "FragmentDensityProcessEXT | ";
938     if ( value & PipelineStageFlagBits2::eTaskShaderEXT ) result += "TaskShaderEXT | ";
939     if ( value & PipelineStageFlagBits2::eMeshShaderEXT ) result += "MeshShaderEXT | ";
940 
941     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
942   }
943 
to_string(AccessFlags2 value)944   VULKAN_HPP_INLINE std::string to_string( AccessFlags2 value )
945   {
946     if ( !value )
947       return "None";
948 
949     std::string result;
950     if ( value & AccessFlagBits2::eIndirectCommandRead ) result += "IndirectCommandRead | ";
951     if ( value & AccessFlagBits2::eIndexRead ) result += "IndexRead | ";
952     if ( value & AccessFlagBits2::eVertexAttributeRead ) result += "VertexAttributeRead | ";
953     if ( value & AccessFlagBits2::eUniformRead ) result += "UniformRead | ";
954     if ( value & AccessFlagBits2::eInputAttachmentRead ) result += "InputAttachmentRead | ";
955     if ( value & AccessFlagBits2::eShaderRead ) result += "ShaderRead | ";
956     if ( value & AccessFlagBits2::eShaderWrite ) result += "ShaderWrite | ";
957     if ( value & AccessFlagBits2::eColorAttachmentRead ) result += "ColorAttachmentRead | ";
958     if ( value & AccessFlagBits2::eColorAttachmentWrite ) result += "ColorAttachmentWrite | ";
959     if ( value & AccessFlagBits2::eDepthStencilAttachmentRead ) result += "DepthStencilAttachmentRead | ";
960     if ( value & AccessFlagBits2::eDepthStencilAttachmentWrite ) result += "DepthStencilAttachmentWrite | ";
961     if ( value & AccessFlagBits2::eTransferRead ) result += "TransferRead | ";
962     if ( value & AccessFlagBits2::eTransferWrite ) result += "TransferWrite | ";
963     if ( value & AccessFlagBits2::eHostRead ) result += "HostRead | ";
964     if ( value & AccessFlagBits2::eHostWrite ) result += "HostWrite | ";
965     if ( value & AccessFlagBits2::eMemoryRead ) result += "MemoryRead | ";
966     if ( value & AccessFlagBits2::eMemoryWrite ) result += "MemoryWrite | ";
967     if ( value & AccessFlagBits2::eShaderSampledRead ) result += "ShaderSampledRead | ";
968     if ( value & AccessFlagBits2::eShaderStorageRead ) result += "ShaderStorageRead | ";
969     if ( value & AccessFlagBits2::eShaderStorageWrite ) result += "ShaderStorageWrite | ";
970     if ( value & AccessFlagBits2::eTransformFeedbackWriteEXT ) result += "TransformFeedbackWriteEXT | ";
971     if ( value & AccessFlagBits2::eTransformFeedbackCounterReadEXT ) result += "TransformFeedbackCounterReadEXT | ";
972     if ( value & AccessFlagBits2::eTransformFeedbackCounterWriteEXT ) result += "TransformFeedbackCounterWriteEXT | ";
973     if ( value & AccessFlagBits2::eConditionalRenderingReadEXT ) result += "ConditionalRenderingReadEXT | ";
974     if ( value & AccessFlagBits2::eCommandPreprocessReadNV ) result += "CommandPreprocessReadNV | ";
975     if ( value & AccessFlagBits2::eCommandPreprocessWriteNV ) result += "CommandPreprocessWriteNV | ";
976     if ( value & AccessFlagBits2::eFragmentShadingRateAttachmentReadKHR ) result += "FragmentShadingRateAttachmentReadKHR | ";
977     if ( value & AccessFlagBits2::eAccelerationStructureReadKHR ) result += "AccelerationStructureReadKHR | ";
978     if ( value & AccessFlagBits2::eAccelerationStructureWriteKHR ) result += "AccelerationStructureWriteKHR | ";
979     if ( value & AccessFlagBits2::eFragmentDensityMapReadEXT ) result += "FragmentDensityMapReadEXT | ";
980     if ( value & AccessFlagBits2::eColorAttachmentReadNoncoherentEXT ) result += "ColorAttachmentReadNoncoherentEXT | ";
981 
982     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
983   }
984 
to_string(SubmitFlags value)985   VULKAN_HPP_INLINE std::string to_string( SubmitFlags value )
986   {
987     if ( !value )
988       return "{}";
989 
990     std::string result;
991     if ( value & SubmitFlagBits::eProtected ) result += "Protected | ";
992 
993     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
994   }
995 
to_string(RenderingFlags value)996   VULKAN_HPP_INLINE std::string to_string( RenderingFlags value )
997   {
998     if ( !value )
999       return "{}";
1000 
1001     std::string result;
1002     if ( value & RenderingFlagBits::eContentsSecondaryCommandBuffers ) result += "ContentsSecondaryCommandBuffers | ";
1003     if ( value & RenderingFlagBits::eSuspending ) result += "Suspending | ";
1004     if ( value & RenderingFlagBits::eResuming ) result += "Resuming | ";
1005 
1006     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
1007   }
1008 
to_string(FormatFeatureFlags2 value)1009   VULKAN_HPP_INLINE std::string to_string( FormatFeatureFlags2 value )
1010   {
1011     if ( !value )
1012       return "{}";
1013 
1014     std::string result;
1015     if ( value & FormatFeatureFlagBits2::eSampledImage ) result += "SampledImage | ";
1016     if ( value & FormatFeatureFlagBits2::eStorageImage ) result += "StorageImage | ";
1017     if ( value & FormatFeatureFlagBits2::eStorageImageAtomic ) result += "StorageImageAtomic | ";
1018     if ( value & FormatFeatureFlagBits2::eUniformTexelBuffer ) result += "UniformTexelBuffer | ";
1019     if ( value & FormatFeatureFlagBits2::eStorageTexelBuffer ) result += "StorageTexelBuffer | ";
1020     if ( value & FormatFeatureFlagBits2::eStorageTexelBufferAtomic ) result += "StorageTexelBufferAtomic | ";
1021     if ( value & FormatFeatureFlagBits2::eVertexBuffer ) result += "VertexBuffer | ";
1022     if ( value & FormatFeatureFlagBits2::eColorAttachment ) result += "ColorAttachment | ";
1023     if ( value & FormatFeatureFlagBits2::eColorAttachmentBlend ) result += "ColorAttachmentBlend | ";
1024     if ( value & FormatFeatureFlagBits2::eDepthStencilAttachment ) result += "DepthStencilAttachment | ";
1025     if ( value & FormatFeatureFlagBits2::eBlitSrc ) result += "BlitSrc | ";
1026     if ( value & FormatFeatureFlagBits2::eBlitDst ) result += "BlitDst | ";
1027     if ( value & FormatFeatureFlagBits2::eSampledImageFilterLinear ) result += "SampledImageFilterLinear | ";
1028     if ( value & FormatFeatureFlagBits2::eSampledImageFilterCubic ) result += "SampledImageFilterCubic | ";
1029     if ( value & FormatFeatureFlagBits2::eTransferSrc ) result += "TransferSrc | ";
1030     if ( value & FormatFeatureFlagBits2::eTransferDst ) result += "TransferDst | ";
1031     if ( value & FormatFeatureFlagBits2::eSampledImageFilterMinmax ) result += "SampledImageFilterMinmax | ";
1032     if ( value & FormatFeatureFlagBits2::eMidpointChromaSamples ) result += "MidpointChromaSamples | ";
1033     if ( value & FormatFeatureFlagBits2::eSampledImageYcbcrConversionLinearFilter ) result += "SampledImageYcbcrConversionLinearFilter | ";
1034     if ( value & FormatFeatureFlagBits2::eSampledImageYcbcrConversionSeparateReconstructionFilter ) result += "SampledImageYcbcrConversionSeparateReconstructionFilter | ";
1035     if ( value & FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicit ) result += "SampledImageYcbcrConversionChromaReconstructionExplicit | ";
1036     if ( value & FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable ) result += "SampledImageYcbcrConversionChromaReconstructionExplicitForceable | ";
1037     if ( value & FormatFeatureFlagBits2::eDisjoint ) result += "Disjoint | ";
1038     if ( value & FormatFeatureFlagBits2::eCositedChromaSamples ) result += "CositedChromaSamples | ";
1039     if ( value & FormatFeatureFlagBits2::eStorageReadWithoutFormat ) result += "StorageReadWithoutFormat | ";
1040     if ( value & FormatFeatureFlagBits2::eStorageWriteWithoutFormat ) result += "StorageWriteWithoutFormat | ";
1041     if ( value & FormatFeatureFlagBits2::eSampledImageDepthComparison ) result += "SampledImageDepthComparison | ";
1042     if ( value & FormatFeatureFlagBits2::eFragmentShadingRateAttachmentKHR ) result += "FragmentShadingRateAttachmentKHR | ";
1043 
1044     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
1045   }
1046 
1047   //=== VK_KHR_surface ===
1048 
to_string(CompositeAlphaFlagsKHR value)1049   VULKAN_HPP_INLINE std::string to_string( CompositeAlphaFlagsKHR value )
1050   {
1051     if ( !value )
1052       return "{}";
1053 
1054     std::string result;
1055     if ( value & CompositeAlphaFlagBitsKHR::eOpaque ) result += "Opaque | ";
1056     if ( value & CompositeAlphaFlagBitsKHR::ePreMultiplied ) result += "PreMultiplied | ";
1057     if ( value & CompositeAlphaFlagBitsKHR::ePostMultiplied ) result += "PostMultiplied | ";
1058     if ( value & CompositeAlphaFlagBitsKHR::eInherit ) result += "Inherit | ";
1059 
1060     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
1061   }
1062 
1063   //=== VK_KHR_swapchain ===
1064 
to_string(SwapchainCreateFlagsKHR value)1065   VULKAN_HPP_INLINE std::string to_string( SwapchainCreateFlagsKHR value )
1066   {
1067     if ( !value )
1068       return "{}";
1069 
1070     std::string result;
1071     if ( value & SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions ) result += "SplitInstanceBindRegions | ";
1072     if ( value & SwapchainCreateFlagBitsKHR::eProtected ) result += "Protected | ";
1073     if ( value & SwapchainCreateFlagBitsKHR::eMutableFormat ) result += "MutableFormat | ";
1074 
1075     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
1076   }
1077 
to_string(DeviceGroupPresentModeFlagsKHR value)1078   VULKAN_HPP_INLINE std::string to_string( DeviceGroupPresentModeFlagsKHR value )
1079   {
1080     if ( !value )
1081       return "{}";
1082 
1083     std::string result;
1084     if ( value & DeviceGroupPresentModeFlagBitsKHR::eLocal ) result += "Local | ";
1085     if ( value & DeviceGroupPresentModeFlagBitsKHR::eRemote ) result += "Remote | ";
1086     if ( value & DeviceGroupPresentModeFlagBitsKHR::eSum ) result += "Sum | ";
1087     if ( value & DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice ) result += "LocalMultiDevice | ";
1088 
1089     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
1090   }
1091 
1092   //=== VK_KHR_display ===
1093 
to_string(DisplayModeCreateFlagsKHR)1094   VULKAN_HPP_INLINE std::string to_string( DisplayModeCreateFlagsKHR )
1095   {
1096     return "{}";
1097   }
1098 
to_string(DisplayPlaneAlphaFlagsKHR value)1099   VULKAN_HPP_INLINE std::string to_string( DisplayPlaneAlphaFlagsKHR value )
1100   {
1101     if ( !value )
1102       return "{}";
1103 
1104     std::string result;
1105     if ( value & DisplayPlaneAlphaFlagBitsKHR::eOpaque ) result += "Opaque | ";
1106     if ( value & DisplayPlaneAlphaFlagBitsKHR::eGlobal ) result += "Global | ";
1107     if ( value & DisplayPlaneAlphaFlagBitsKHR::ePerPixel ) result += "PerPixel | ";
1108     if ( value & DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied ) result += "PerPixelPremultiplied | ";
1109 
1110     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
1111   }
1112 
to_string(DisplaySurfaceCreateFlagsKHR)1113   VULKAN_HPP_INLINE std::string to_string( DisplaySurfaceCreateFlagsKHR )
1114   {
1115     return "{}";
1116   }
1117 
to_string(SurfaceTransformFlagsKHR value)1118   VULKAN_HPP_INLINE std::string to_string( SurfaceTransformFlagsKHR value )
1119   {
1120     if ( !value )
1121       return "{}";
1122 
1123     std::string result;
1124     if ( value & SurfaceTransformFlagBitsKHR::eIdentity ) result += "Identity | ";
1125     if ( value & SurfaceTransformFlagBitsKHR::eRotate90 ) result += "Rotate90 | ";
1126     if ( value & SurfaceTransformFlagBitsKHR::eRotate180 ) result += "Rotate180 | ";
1127     if ( value & SurfaceTransformFlagBitsKHR::eRotate270 ) result += "Rotate270 | ";
1128     if ( value & SurfaceTransformFlagBitsKHR::eHorizontalMirror ) result += "HorizontalMirror | ";
1129     if ( value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90 ) result += "HorizontalMirrorRotate90 | ";
1130     if ( value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180 ) result += "HorizontalMirrorRotate180 | ";
1131     if ( value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270 ) result += "HorizontalMirrorRotate270 | ";
1132     if ( value & SurfaceTransformFlagBitsKHR::eInherit ) result += "Inherit | ";
1133 
1134     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
1135   }
1136 
1137   //=== VK_EXT_display_surface_counter ===
1138 
to_string(SurfaceCounterFlagsEXT value)1139   VULKAN_HPP_INLINE std::string to_string( SurfaceCounterFlagsEXT value )
1140   {
1141     if ( !value )
1142       return "{}";
1143 
1144     std::string result;
1145     if ( value & SurfaceCounterFlagBitsEXT::eVblank ) result += "Vblank | ";
1146 
1147     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
1148   }
1149 
1150   //=== VK_EXT_discard_rectangles ===
1151 
to_string(PipelineDiscardRectangleStateCreateFlagsEXT)1152   VULKAN_HPP_INLINE std::string to_string( PipelineDiscardRectangleStateCreateFlagsEXT )
1153   {
1154     return "{}";
1155   }
1156 
1157   //=== VK_EXT_conservative_rasterization ===
1158 
to_string(PipelineRasterizationConservativeStateCreateFlagsEXT)1159   VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationConservativeStateCreateFlagsEXT )
1160   {
1161     return "{}";
1162   }
1163 
1164   //=== VK_EXT_depth_clip_enable ===
1165 
to_string(PipelineRasterizationDepthClipStateCreateFlagsEXT)1166   VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationDepthClipStateCreateFlagsEXT )
1167   {
1168     return "{}";
1169   }
1170 
1171   //=== VK_KHR_performance_query ===
1172 
to_string(PerformanceCounterDescriptionFlagsKHR value)1173   VULKAN_HPP_INLINE std::string to_string( PerformanceCounterDescriptionFlagsKHR value )
1174   {
1175     if ( !value )
1176       return "{}";
1177 
1178     std::string result;
1179     if ( value & PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting ) result += "PerformanceImpacting | ";
1180     if ( value & PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted ) result += "ConcurrentlyImpacted | ";
1181 
1182     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
1183   }
1184 
to_string(AcquireProfilingLockFlagsKHR)1185   VULKAN_HPP_INLINE std::string to_string( AcquireProfilingLockFlagsKHR )
1186   {
1187     return "{}";
1188   }
1189 
1190   //=== VK_EXT_debug_utils ===
1191 
to_string(DebugUtilsMessageSeverityFlagsEXT value)1192   VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessageSeverityFlagsEXT value )
1193   {
1194     if ( !value )
1195       return "{}";
1196 
1197     std::string result;
1198     if ( value & DebugUtilsMessageSeverityFlagBitsEXT::eVerbose ) result += "Verbose | ";
1199     if ( value & DebugUtilsMessageSeverityFlagBitsEXT::eInfo ) result += "Info | ";
1200     if ( value & DebugUtilsMessageSeverityFlagBitsEXT::eWarning ) result += "Warning | ";
1201     if ( value & DebugUtilsMessageSeverityFlagBitsEXT::eError ) result += "Error | ";
1202 
1203     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
1204   }
1205 
to_string(DebugUtilsMessageTypeFlagsEXT value)1206   VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessageTypeFlagsEXT value )
1207   {
1208     if ( !value )
1209       return "{}";
1210 
1211     std::string result;
1212     if ( value & DebugUtilsMessageTypeFlagBitsEXT::eGeneral ) result += "General | ";
1213     if ( value & DebugUtilsMessageTypeFlagBitsEXT::eValidation ) result += "Validation | ";
1214     if ( value & DebugUtilsMessageTypeFlagBitsEXT::ePerformance ) result += "Performance | ";
1215 
1216     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
1217   }
1218 
to_string(DebugUtilsMessengerCallbackDataFlagsEXT)1219   VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCallbackDataFlagsEXT )
1220   {
1221     return "{}";
1222   }
1223 
to_string(DebugUtilsMessengerCreateFlagsEXT)1224   VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCreateFlagsEXT )
1225   {
1226     return "{}";
1227   }
1228 
1229   //=== VK_EXT_headless_surface ===
1230 
to_string(HeadlessSurfaceCreateFlagsEXT)1231   VULKAN_HPP_INLINE std::string to_string( HeadlessSurfaceCreateFlagsEXT )
1232   {
1233     return "{}";
1234   }
1235 
1236   //=== VK_KHR_object_refresh ===
1237 
to_string(RefreshObjectFlagsKHR)1238   VULKAN_HPP_INLINE std::string to_string( RefreshObjectFlagsKHR )
1239   {
1240     return "{}";
1241   }
1242 
1243 
1244 
1245   //=======================
1246   //=== ENUMs to_string ===
1247   //=======================
1248 
toHexString(uint32_t value)1249   VULKAN_HPP_INLINE std::string toHexString( uint32_t value )
1250   {
1251 #if __cpp_lib_format
1252     return std::format( "{:x}", value );
1253 #else
1254     std::stringstream stream;
1255     stream << std::hex << value;
1256     return stream.str();
1257 #endif
1258   }
1259 
1260 
1261   //=== VK_VERSION_1_0 ===
1262 
1263 
to_string(Result value)1264   VULKAN_HPP_INLINE std::string to_string( Result value )
1265   {
1266     switch ( value )
1267     {
1268       case Result::eSuccess : return "Success";
1269       case Result::eNotReady : return "NotReady";
1270       case Result::eTimeout : return "Timeout";
1271       case Result::eEventSet : return "EventSet";
1272       case Result::eEventReset : return "EventReset";
1273       case Result::eIncomplete : return "Incomplete";
1274       case Result::eErrorOutOfHostMemory : return "ErrorOutOfHostMemory";
1275       case Result::eErrorOutOfDeviceMemory : return "ErrorOutOfDeviceMemory";
1276       case Result::eErrorInitializationFailed : return "ErrorInitializationFailed";
1277       case Result::eErrorDeviceLost : return "ErrorDeviceLost";
1278       case Result::eErrorMemoryMapFailed : return "ErrorMemoryMapFailed";
1279       case Result::eErrorLayerNotPresent : return "ErrorLayerNotPresent";
1280       case Result::eErrorExtensionNotPresent : return "ErrorExtensionNotPresent";
1281       case Result::eErrorFeatureNotPresent : return "ErrorFeatureNotPresent";
1282       case Result::eErrorIncompatibleDriver : return "ErrorIncompatibleDriver";
1283       case Result::eErrorTooManyObjects : return "ErrorTooManyObjects";
1284       case Result::eErrorFormatNotSupported : return "ErrorFormatNotSupported";
1285       case Result::eErrorFragmentedPool : return "ErrorFragmentedPool";
1286       case Result::eErrorUnknown : return "ErrorUnknown";
1287       case Result::eErrorOutOfPoolMemory : return "ErrorOutOfPoolMemory";
1288       case Result::eErrorInvalidExternalHandle : return "ErrorInvalidExternalHandle";
1289       case Result::eErrorFragmentation : return "ErrorFragmentation";
1290       case Result::eErrorInvalidOpaqueCaptureAddress : return "ErrorInvalidOpaqueCaptureAddress";
1291       case Result::ePipelineCompileRequired : return "PipelineCompileRequired";
1292       case Result::eErrorValidationFailed : return "ErrorValidationFailed";
1293       case Result::eErrorInvalidPipelineCacheData : return "ErrorInvalidPipelineCacheData";
1294       case Result::eErrorNoPipelineMatch : return "ErrorNoPipelineMatch";
1295       case Result::eErrorSurfaceLostKHR : return "ErrorSurfaceLostKHR";
1296       case Result::eErrorNativeWindowInUseKHR : return "ErrorNativeWindowInUseKHR";
1297       case Result::eSuboptimalKHR : return "SuboptimalKHR";
1298       case Result::eErrorOutOfDateKHR : return "ErrorOutOfDateKHR";
1299       case Result::eErrorIncompatibleDisplayKHR : return "ErrorIncompatibleDisplayKHR";
1300       case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT : return "ErrorInvalidDrmFormatModifierPlaneLayoutEXT";
1301       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
1302     }
1303 
1304   }
1305 
1306 
to_string(StructureType value)1307   VULKAN_HPP_INLINE std::string to_string( StructureType value )
1308   {
1309     switch ( value )
1310     {
1311       case StructureType::eApplicationInfo : return "ApplicationInfo";
1312       case StructureType::eInstanceCreateInfo : return "InstanceCreateInfo";
1313       case StructureType::eDeviceQueueCreateInfo : return "DeviceQueueCreateInfo";
1314       case StructureType::eDeviceCreateInfo : return "DeviceCreateInfo";
1315       case StructureType::eSubmitInfo : return "SubmitInfo";
1316       case StructureType::eMemoryAllocateInfo : return "MemoryAllocateInfo";
1317       case StructureType::eMappedMemoryRange : return "MappedMemoryRange";
1318       case StructureType::eFenceCreateInfo : return "FenceCreateInfo";
1319       case StructureType::eSemaphoreCreateInfo : return "SemaphoreCreateInfo";
1320       case StructureType::eEventCreateInfo : return "EventCreateInfo";
1321       case StructureType::eQueryPoolCreateInfo : return "QueryPoolCreateInfo";
1322       case StructureType::eBufferCreateInfo : return "BufferCreateInfo";
1323       case StructureType::eBufferViewCreateInfo : return "BufferViewCreateInfo";
1324       case StructureType::eImageCreateInfo : return "ImageCreateInfo";
1325       case StructureType::eImageViewCreateInfo : return "ImageViewCreateInfo";
1326       case StructureType::ePipelineCacheCreateInfo : return "PipelineCacheCreateInfo";
1327       case StructureType::ePipelineShaderStageCreateInfo : return "PipelineShaderStageCreateInfo";
1328       case StructureType::ePipelineVertexInputStateCreateInfo : return "PipelineVertexInputStateCreateInfo";
1329       case StructureType::ePipelineInputAssemblyStateCreateInfo : return "PipelineInputAssemblyStateCreateInfo";
1330       case StructureType::ePipelineTessellationStateCreateInfo : return "PipelineTessellationStateCreateInfo";
1331       case StructureType::ePipelineViewportStateCreateInfo : return "PipelineViewportStateCreateInfo";
1332       case StructureType::ePipelineRasterizationStateCreateInfo : return "PipelineRasterizationStateCreateInfo";
1333       case StructureType::ePipelineMultisampleStateCreateInfo : return "PipelineMultisampleStateCreateInfo";
1334       case StructureType::ePipelineDepthStencilStateCreateInfo : return "PipelineDepthStencilStateCreateInfo";
1335       case StructureType::ePipelineColorBlendStateCreateInfo : return "PipelineColorBlendStateCreateInfo";
1336       case StructureType::ePipelineDynamicStateCreateInfo : return "PipelineDynamicStateCreateInfo";
1337       case StructureType::eGraphicsPipelineCreateInfo : return "GraphicsPipelineCreateInfo";
1338       case StructureType::eComputePipelineCreateInfo : return "ComputePipelineCreateInfo";
1339       case StructureType::ePipelineLayoutCreateInfo : return "PipelineLayoutCreateInfo";
1340       case StructureType::eSamplerCreateInfo : return "SamplerCreateInfo";
1341       case StructureType::eDescriptorSetLayoutCreateInfo : return "DescriptorSetLayoutCreateInfo";
1342       case StructureType::eDescriptorPoolCreateInfo : return "DescriptorPoolCreateInfo";
1343       case StructureType::eDescriptorSetAllocateInfo : return "DescriptorSetAllocateInfo";
1344       case StructureType::eWriteDescriptorSet : return "WriteDescriptorSet";
1345       case StructureType::eCopyDescriptorSet : return "CopyDescriptorSet";
1346       case StructureType::eFramebufferCreateInfo : return "FramebufferCreateInfo";
1347       case StructureType::eRenderPassCreateInfo : return "RenderPassCreateInfo";
1348       case StructureType::eCommandPoolCreateInfo : return "CommandPoolCreateInfo";
1349       case StructureType::eCommandBufferAllocateInfo : return "CommandBufferAllocateInfo";
1350       case StructureType::eCommandBufferInheritanceInfo : return "CommandBufferInheritanceInfo";
1351       case StructureType::eCommandBufferBeginInfo : return "CommandBufferBeginInfo";
1352       case StructureType::eRenderPassBeginInfo : return "RenderPassBeginInfo";
1353       case StructureType::eBufferMemoryBarrier : return "BufferMemoryBarrier";
1354       case StructureType::eImageMemoryBarrier : return "ImageMemoryBarrier";
1355       case StructureType::eMemoryBarrier : return "MemoryBarrier";
1356       case StructureType::eLoaderInstanceCreateInfo : return "LoaderInstanceCreateInfo";
1357       case StructureType::eLoaderDeviceCreateInfo : return "LoaderDeviceCreateInfo";
1358       case StructureType::ePhysicalDeviceSubgroupProperties : return "PhysicalDeviceSubgroupProperties";
1359       case StructureType::eBindBufferMemoryInfo : return "BindBufferMemoryInfo";
1360       case StructureType::eBindImageMemoryInfo : return "BindImageMemoryInfo";
1361       case StructureType::ePhysicalDevice16BitStorageFeatures : return "PhysicalDevice16BitStorageFeatures";
1362       case StructureType::eMemoryDedicatedRequirements : return "MemoryDedicatedRequirements";
1363       case StructureType::eMemoryDedicatedAllocateInfo : return "MemoryDedicatedAllocateInfo";
1364       case StructureType::eMemoryAllocateFlagsInfo : return "MemoryAllocateFlagsInfo";
1365       case StructureType::eDeviceGroupRenderPassBeginInfo : return "DeviceGroupRenderPassBeginInfo";
1366       case StructureType::eDeviceGroupCommandBufferBeginInfo : return "DeviceGroupCommandBufferBeginInfo";
1367       case StructureType::eDeviceGroupSubmitInfo : return "DeviceGroupSubmitInfo";
1368       case StructureType::eBindBufferMemoryDeviceGroupInfo : return "BindBufferMemoryDeviceGroupInfo";
1369       case StructureType::eBindImageMemoryDeviceGroupInfo : return "BindImageMemoryDeviceGroupInfo";
1370       case StructureType::ePhysicalDeviceGroupProperties : return "PhysicalDeviceGroupProperties";
1371       case StructureType::eDeviceGroupDeviceCreateInfo : return "DeviceGroupDeviceCreateInfo";
1372       case StructureType::eBufferMemoryRequirementsInfo2 : return "BufferMemoryRequirementsInfo2";
1373       case StructureType::eImageMemoryRequirementsInfo2 : return "ImageMemoryRequirementsInfo2";
1374       case StructureType::eMemoryRequirements2 : return "MemoryRequirements2";
1375       case StructureType::ePhysicalDeviceFeatures2 : return "PhysicalDeviceFeatures2";
1376       case StructureType::ePhysicalDeviceProperties2 : return "PhysicalDeviceProperties2";
1377       case StructureType::eFormatProperties2 : return "FormatProperties2";
1378       case StructureType::eImageFormatProperties2 : return "ImageFormatProperties2";
1379       case StructureType::ePhysicalDeviceImageFormatInfo2 : return "PhysicalDeviceImageFormatInfo2";
1380       case StructureType::eQueueFamilyProperties2 : return "QueueFamilyProperties2";
1381       case StructureType::ePhysicalDeviceMemoryProperties2 : return "PhysicalDeviceMemoryProperties2";
1382       case StructureType::ePhysicalDevicePointClippingProperties : return "PhysicalDevicePointClippingProperties";
1383       case StructureType::eRenderPassInputAttachmentAspectCreateInfo : return "RenderPassInputAttachmentAspectCreateInfo";
1384       case StructureType::eImageViewUsageCreateInfo : return "ImageViewUsageCreateInfo";
1385       case StructureType::ePipelineTessellationDomainOriginStateCreateInfo : return "PipelineTessellationDomainOriginStateCreateInfo";
1386       case StructureType::eRenderPassMultiviewCreateInfo : return "RenderPassMultiviewCreateInfo";
1387       case StructureType::ePhysicalDeviceMultiviewFeatures : return "PhysicalDeviceMultiviewFeatures";
1388       case StructureType::ePhysicalDeviceMultiviewProperties : return "PhysicalDeviceMultiviewProperties";
1389       case StructureType::ePhysicalDeviceVariablePointersFeatures : return "PhysicalDeviceVariablePointersFeatures";
1390       case StructureType::eProtectedSubmitInfo : return "ProtectedSubmitInfo";
1391       case StructureType::ePhysicalDeviceProtectedMemoryFeatures : return "PhysicalDeviceProtectedMemoryFeatures";
1392       case StructureType::ePhysicalDeviceProtectedMemoryProperties : return "PhysicalDeviceProtectedMemoryProperties";
1393       case StructureType::eDeviceQueueInfo2 : return "DeviceQueueInfo2";
1394       case StructureType::eSamplerYcbcrConversionCreateInfo : return "SamplerYcbcrConversionCreateInfo";
1395       case StructureType::eSamplerYcbcrConversionInfo : return "SamplerYcbcrConversionInfo";
1396       case StructureType::eBindImagePlaneMemoryInfo : return "BindImagePlaneMemoryInfo";
1397       case StructureType::eImagePlaneMemoryRequirementsInfo : return "ImagePlaneMemoryRequirementsInfo";
1398       case StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures : return "PhysicalDeviceSamplerYcbcrConversionFeatures";
1399       case StructureType::eSamplerYcbcrConversionImageFormatProperties : return "SamplerYcbcrConversionImageFormatProperties";
1400       case StructureType::ePhysicalDeviceExternalImageFormatInfo : return "PhysicalDeviceExternalImageFormatInfo";
1401       case StructureType::eExternalImageFormatProperties : return "ExternalImageFormatProperties";
1402       case StructureType::ePhysicalDeviceExternalBufferInfo : return "PhysicalDeviceExternalBufferInfo";
1403       case StructureType::eExternalBufferProperties : return "ExternalBufferProperties";
1404       case StructureType::ePhysicalDeviceIdProperties : return "PhysicalDeviceIdProperties";
1405       case StructureType::eExternalMemoryBufferCreateInfo : return "ExternalMemoryBufferCreateInfo";
1406       case StructureType::eExternalMemoryImageCreateInfo : return "ExternalMemoryImageCreateInfo";
1407       case StructureType::eExportMemoryAllocateInfo : return "ExportMemoryAllocateInfo";
1408       case StructureType::ePhysicalDeviceExternalFenceInfo : return "PhysicalDeviceExternalFenceInfo";
1409       case StructureType::eExternalFenceProperties : return "ExternalFenceProperties";
1410       case StructureType::eExportFenceCreateInfo : return "ExportFenceCreateInfo";
1411       case StructureType::eExportSemaphoreCreateInfo : return "ExportSemaphoreCreateInfo";
1412       case StructureType::ePhysicalDeviceExternalSemaphoreInfo : return "PhysicalDeviceExternalSemaphoreInfo";
1413       case StructureType::eExternalSemaphoreProperties : return "ExternalSemaphoreProperties";
1414       case StructureType::ePhysicalDeviceMaintenance3Properties : return "PhysicalDeviceMaintenance3Properties";
1415       case StructureType::eDescriptorSetLayoutSupport : return "DescriptorSetLayoutSupport";
1416       case StructureType::ePhysicalDeviceShaderDrawParametersFeatures : return "PhysicalDeviceShaderDrawParametersFeatures";
1417       case StructureType::ePhysicalDeviceVulkan11Features : return "PhysicalDeviceVulkan11Features";
1418       case StructureType::ePhysicalDeviceVulkan11Properties : return "PhysicalDeviceVulkan11Properties";
1419       case StructureType::ePhysicalDeviceVulkan12Features : return "PhysicalDeviceVulkan12Features";
1420       case StructureType::ePhysicalDeviceVulkan12Properties : return "PhysicalDeviceVulkan12Properties";
1421       case StructureType::eImageFormatListCreateInfo : return "ImageFormatListCreateInfo";
1422       case StructureType::eAttachmentDescription2 : return "AttachmentDescription2";
1423       case StructureType::eAttachmentReference2 : return "AttachmentReference2";
1424       case StructureType::eSubpassDescription2 : return "SubpassDescription2";
1425       case StructureType::eSubpassDependency2 : return "SubpassDependency2";
1426       case StructureType::eRenderPassCreateInfo2 : return "RenderPassCreateInfo2";
1427       case StructureType::eSubpassBeginInfo : return "SubpassBeginInfo";
1428       case StructureType::eSubpassEndInfo : return "SubpassEndInfo";
1429       case StructureType::ePhysicalDevice8BitStorageFeatures : return "PhysicalDevice8BitStorageFeatures";
1430       case StructureType::ePhysicalDeviceDriverProperties : return "PhysicalDeviceDriverProperties";
1431       case StructureType::ePhysicalDeviceShaderAtomicInt64Features : return "PhysicalDeviceShaderAtomicInt64Features";
1432       case StructureType::ePhysicalDeviceShaderFloat16Int8Features : return "PhysicalDeviceShaderFloat16Int8Features";
1433       case StructureType::ePhysicalDeviceFloatControlsProperties : return "PhysicalDeviceFloatControlsProperties";
1434       case StructureType::eDescriptorSetLayoutBindingFlagsCreateInfo : return "DescriptorSetLayoutBindingFlagsCreateInfo";
1435       case StructureType::ePhysicalDeviceDescriptorIndexingFeatures : return "PhysicalDeviceDescriptorIndexingFeatures";
1436       case StructureType::ePhysicalDeviceDescriptorIndexingProperties : return "PhysicalDeviceDescriptorIndexingProperties";
1437       case StructureType::eDescriptorSetVariableDescriptorCountAllocateInfo : return "DescriptorSetVariableDescriptorCountAllocateInfo";
1438       case StructureType::eDescriptorSetVariableDescriptorCountLayoutSupport : return "DescriptorSetVariableDescriptorCountLayoutSupport";
1439       case StructureType::ePhysicalDeviceDepthStencilResolveProperties : return "PhysicalDeviceDepthStencilResolveProperties";
1440       case StructureType::eSubpassDescriptionDepthStencilResolve : return "SubpassDescriptionDepthStencilResolve";
1441       case StructureType::ePhysicalDeviceScalarBlockLayoutFeatures : return "PhysicalDeviceScalarBlockLayoutFeatures";
1442       case StructureType::eImageStencilUsageCreateInfo : return "ImageStencilUsageCreateInfo";
1443       case StructureType::ePhysicalDeviceSamplerFilterMinmaxProperties : return "PhysicalDeviceSamplerFilterMinmaxProperties";
1444       case StructureType::eSamplerReductionModeCreateInfo : return "SamplerReductionModeCreateInfo";
1445       case StructureType::ePhysicalDeviceVulkanMemoryModelFeatures : return "PhysicalDeviceVulkanMemoryModelFeatures";
1446       case StructureType::ePhysicalDeviceImagelessFramebufferFeatures : return "PhysicalDeviceImagelessFramebufferFeatures";
1447       case StructureType::eFramebufferAttachmentsCreateInfo : return "FramebufferAttachmentsCreateInfo";
1448       case StructureType::eFramebufferAttachmentImageInfo : return "FramebufferAttachmentImageInfo";
1449       case StructureType::eRenderPassAttachmentBeginInfo : return "RenderPassAttachmentBeginInfo";
1450       case StructureType::ePhysicalDeviceUniformBufferStandardLayoutFeatures : return "PhysicalDeviceUniformBufferStandardLayoutFeatures";
1451       case StructureType::ePhysicalDeviceShaderSubgroupExtendedTypesFeatures : return "PhysicalDeviceShaderSubgroupExtendedTypesFeatures";
1452       case StructureType::ePhysicalDeviceSeparateDepthStencilLayoutsFeatures : return "PhysicalDeviceSeparateDepthStencilLayoutsFeatures";
1453       case StructureType::eAttachmentReferenceStencilLayout : return "AttachmentReferenceStencilLayout";
1454       case StructureType::eAttachmentDescriptionStencilLayout : return "AttachmentDescriptionStencilLayout";
1455       case StructureType::ePhysicalDeviceHostQueryResetFeatures : return "PhysicalDeviceHostQueryResetFeatures";
1456       case StructureType::ePhysicalDeviceTimelineSemaphoreFeatures : return "PhysicalDeviceTimelineSemaphoreFeatures";
1457       case StructureType::ePhysicalDeviceTimelineSemaphoreProperties : return "PhysicalDeviceTimelineSemaphoreProperties";
1458       case StructureType::eSemaphoreTypeCreateInfo : return "SemaphoreTypeCreateInfo";
1459       case StructureType::eTimelineSemaphoreSubmitInfo : return "TimelineSemaphoreSubmitInfo";
1460       case StructureType::eSemaphoreWaitInfo : return "SemaphoreWaitInfo";
1461       case StructureType::eSemaphoreSignalInfo : return "SemaphoreSignalInfo";
1462       case StructureType::ePhysicalDeviceBufferDeviceAddressFeatures : return "PhysicalDeviceBufferDeviceAddressFeatures";
1463       case StructureType::eBufferDeviceAddressInfo : return "BufferDeviceAddressInfo";
1464       case StructureType::eBufferOpaqueCaptureAddressCreateInfo : return "BufferOpaqueCaptureAddressCreateInfo";
1465       case StructureType::eMemoryOpaqueCaptureAddressAllocateInfo : return "MemoryOpaqueCaptureAddressAllocateInfo";
1466       case StructureType::eDeviceMemoryOpaqueCaptureAddressInfo : return "DeviceMemoryOpaqueCaptureAddressInfo";
1467       case StructureType::ePhysicalDeviceVulkan13Features : return "PhysicalDeviceVulkan13Features";
1468       case StructureType::ePhysicalDeviceVulkan13Properties : return "PhysicalDeviceVulkan13Properties";
1469       case StructureType::ePipelineCreationFeedbackCreateInfo : return "PipelineCreationFeedbackCreateInfo";
1470       case StructureType::ePhysicalDeviceShaderTerminateInvocationFeatures : return "PhysicalDeviceShaderTerminateInvocationFeatures";
1471       case StructureType::ePhysicalDeviceToolProperties : return "PhysicalDeviceToolProperties";
1472       case StructureType::ePhysicalDeviceShaderDemoteToHelperInvocationFeatures : return "PhysicalDeviceShaderDemoteToHelperInvocationFeatures";
1473       case StructureType::ePhysicalDevicePrivateDataFeatures : return "PhysicalDevicePrivateDataFeatures";
1474       case StructureType::eDevicePrivateDataCreateInfo : return "DevicePrivateDataCreateInfo";
1475       case StructureType::ePrivateDataSlotCreateInfo : return "PrivateDataSlotCreateInfo";
1476       case StructureType::ePhysicalDevicePipelineCreationCacheControlFeatures : return "PhysicalDevicePipelineCreationCacheControlFeatures";
1477       case StructureType::eMemoryBarrier2 : return "MemoryBarrier2";
1478       case StructureType::eBufferMemoryBarrier2 : return "BufferMemoryBarrier2";
1479       case StructureType::eImageMemoryBarrier2 : return "ImageMemoryBarrier2";
1480       case StructureType::eDependencyInfo : return "DependencyInfo";
1481       case StructureType::eSubmitInfo2 : return "SubmitInfo2";
1482       case StructureType::eSemaphoreSubmitInfo : return "SemaphoreSubmitInfo";
1483       case StructureType::eCommandBufferSubmitInfo : return "CommandBufferSubmitInfo";
1484       case StructureType::ePhysicalDeviceSynchronization2Features : return "PhysicalDeviceSynchronization2Features";
1485       case StructureType::ePhysicalDeviceZeroInitializeWorkgroupMemoryFeatures : return "PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures";
1486       case StructureType::ePhysicalDeviceImageRobustnessFeatures : return "PhysicalDeviceImageRobustnessFeatures";
1487       case StructureType::eCopyBufferInfo2 : return "CopyBufferInfo2";
1488       case StructureType::eCopyImageInfo2 : return "CopyImageInfo2";
1489       case StructureType::eCopyBufferToImageInfo2 : return "CopyBufferToImageInfo2";
1490       case StructureType::eCopyImageToBufferInfo2 : return "CopyImageToBufferInfo2";
1491       case StructureType::eBlitImageInfo2 : return "BlitImageInfo2";
1492       case StructureType::eResolveImageInfo2 : return "ResolveImageInfo2";
1493       case StructureType::eBufferCopy2 : return "BufferCopy2";
1494       case StructureType::eImageCopy2 : return "ImageCopy2";
1495       case StructureType::eImageBlit2 : return "ImageBlit2";
1496       case StructureType::eBufferImageCopy2 : return "BufferImageCopy2";
1497       case StructureType::eImageResolve2 : return "ImageResolve2";
1498       case StructureType::ePhysicalDeviceSubgroupSizeControlProperties : return "PhysicalDeviceSubgroupSizeControlProperties";
1499       case StructureType::ePipelineShaderStageRequiredSubgroupSizeCreateInfo : return "PipelineShaderStageRequiredSubgroupSizeCreateInfo";
1500       case StructureType::ePhysicalDeviceSubgroupSizeControlFeatures : return "PhysicalDeviceSubgroupSizeControlFeatures";
1501       case StructureType::ePhysicalDeviceInlineUniformBlockFeatures : return "PhysicalDeviceInlineUniformBlockFeatures";
1502       case StructureType::ePhysicalDeviceInlineUniformBlockProperties : return "PhysicalDeviceInlineUniformBlockProperties";
1503       case StructureType::eWriteDescriptorSetInlineUniformBlock : return "WriteDescriptorSetInlineUniformBlock";
1504       case StructureType::eDescriptorPoolInlineUniformBlockCreateInfo : return "DescriptorPoolInlineUniformBlockCreateInfo";
1505       case StructureType::ePhysicalDeviceTextureCompressionAstcHdrFeatures : return "PhysicalDeviceTextureCompressionAstcHdrFeatures";
1506       case StructureType::eRenderingInfo : return "RenderingInfo";
1507       case StructureType::eRenderingAttachmentInfo : return "RenderingAttachmentInfo";
1508       case StructureType::ePipelineRenderingCreateInfo : return "PipelineRenderingCreateInfo";
1509       case StructureType::ePhysicalDeviceDynamicRenderingFeatures : return "PhysicalDeviceDynamicRenderingFeatures";
1510       case StructureType::eCommandBufferInheritanceRenderingInfo : return "CommandBufferInheritanceRenderingInfo";
1511       case StructureType::ePhysicalDeviceShaderIntegerDotProductFeatures : return "PhysicalDeviceShaderIntegerDotProductFeatures";
1512       case StructureType::ePhysicalDeviceShaderIntegerDotProductProperties : return "PhysicalDeviceShaderIntegerDotProductProperties";
1513       case StructureType::ePhysicalDeviceTexelBufferAlignmentProperties : return "PhysicalDeviceTexelBufferAlignmentProperties";
1514       case StructureType::eFormatProperties3 : return "FormatProperties3";
1515       case StructureType::ePhysicalDeviceMaintenance4Features : return "PhysicalDeviceMaintenance4Features";
1516       case StructureType::ePhysicalDeviceMaintenance4Properties : return "PhysicalDeviceMaintenance4Properties";
1517       case StructureType::eDeviceBufferMemoryRequirements : return "DeviceBufferMemoryRequirements";
1518       case StructureType::eDeviceImageMemoryRequirements : return "DeviceImageMemoryRequirements";
1519       case StructureType::ePhysicalDeviceVulkanSc10Features : return "PhysicalDeviceVulkanSc10Features";
1520       case StructureType::ePhysicalDeviceVulkanSc10Properties : return "PhysicalDeviceVulkanSc10Properties";
1521       case StructureType::eDeviceObjectReservationCreateInfo : return "DeviceObjectReservationCreateInfo";
1522       case StructureType::eCommandPoolMemoryReservationCreateInfo : return "CommandPoolMemoryReservationCreateInfo";
1523       case StructureType::eCommandPoolMemoryConsumption : return "CommandPoolMemoryConsumption";
1524       case StructureType::ePipelinePoolSize : return "PipelinePoolSize";
1525       case StructureType::eFaultData : return "FaultData";
1526       case StructureType::eFaultCallbackInfo : return "FaultCallbackInfo";
1527       case StructureType::ePipelineOfflineCreateInfo : return "PipelineOfflineCreateInfo";
1528       case StructureType::eSwapchainCreateInfoKHR : return "SwapchainCreateInfoKHR";
1529       case StructureType::ePresentInfoKHR : return "PresentInfoKHR";
1530       case StructureType::eDeviceGroupPresentCapabilitiesKHR : return "DeviceGroupPresentCapabilitiesKHR";
1531       case StructureType::eImageSwapchainCreateInfoKHR : return "ImageSwapchainCreateInfoKHR";
1532       case StructureType::eBindImageMemorySwapchainInfoKHR : return "BindImageMemorySwapchainInfoKHR";
1533       case StructureType::eAcquireNextImageInfoKHR : return "AcquireNextImageInfoKHR";
1534       case StructureType::eDeviceGroupPresentInfoKHR : return "DeviceGroupPresentInfoKHR";
1535       case StructureType::eDeviceGroupSwapchainCreateInfoKHR : return "DeviceGroupSwapchainCreateInfoKHR";
1536       case StructureType::eDisplayModeCreateInfoKHR : return "DisplayModeCreateInfoKHR";
1537       case StructureType::eDisplaySurfaceCreateInfoKHR : return "DisplaySurfaceCreateInfoKHR";
1538       case StructureType::eDisplayPresentInfoKHR : return "DisplayPresentInfoKHR";
1539       case StructureType::ePrivateVendorInfoPlaceholderOffset0NV : return "PrivateVendorInfoPlaceholderOffset0NV";
1540       case StructureType::eImageViewAstcDecodeModeEXT : return "ImageViewAstcDecodeModeEXT";
1541       case StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT : return "PhysicalDeviceAstcDecodeFeaturesEXT";
1542       case StructureType::eImportMemoryFdInfoKHR : return "ImportMemoryFdInfoKHR";
1543       case StructureType::eMemoryFdPropertiesKHR : return "MemoryFdPropertiesKHR";
1544       case StructureType::eMemoryGetFdInfoKHR : return "MemoryGetFdInfoKHR";
1545       case StructureType::eImportSemaphoreFdInfoKHR : return "ImportSemaphoreFdInfoKHR";
1546       case StructureType::eSemaphoreGetFdInfoKHR : return "SemaphoreGetFdInfoKHR";
1547       case StructureType::ePresentRegionsKHR : return "PresentRegionsKHR";
1548       case StructureType::eSurfaceCapabilities2EXT : return "SurfaceCapabilities2EXT";
1549       case StructureType::eDisplayPowerInfoEXT : return "DisplayPowerInfoEXT";
1550       case StructureType::eDeviceEventInfoEXT : return "DeviceEventInfoEXT";
1551       case StructureType::eDisplayEventInfoEXT : return "DisplayEventInfoEXT";
1552       case StructureType::eSwapchainCounterCreateInfoEXT : return "SwapchainCounterCreateInfoEXT";
1553       case StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT : return "PhysicalDeviceDiscardRectanglePropertiesEXT";
1554       case StructureType::ePipelineDiscardRectangleStateCreateInfoEXT : return "PipelineDiscardRectangleStateCreateInfoEXT";
1555       case StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT : return "PhysicalDeviceConservativeRasterizationPropertiesEXT";
1556       case StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT : return "PipelineRasterizationConservativeStateCreateInfoEXT";
1557       case StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT : return "PhysicalDeviceDepthClipEnableFeaturesEXT";
1558       case StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT : return "PipelineRasterizationDepthClipStateCreateInfoEXT";
1559       case StructureType::eHdrMetadataEXT : return "HdrMetadataEXT";
1560       case StructureType::eSharedPresentSurfaceCapabilitiesKHR : return "SharedPresentSurfaceCapabilitiesKHR";
1561       case StructureType::eImportFenceFdInfoKHR : return "ImportFenceFdInfoKHR";
1562       case StructureType::eFenceGetFdInfoKHR : return "FenceGetFdInfoKHR";
1563       case StructureType::ePhysicalDevicePerformanceQueryFeaturesKHR : return "PhysicalDevicePerformanceQueryFeaturesKHR";
1564       case StructureType::ePhysicalDevicePerformanceQueryPropertiesKHR : return "PhysicalDevicePerformanceQueryPropertiesKHR";
1565       case StructureType::eQueryPoolPerformanceCreateInfoKHR : return "QueryPoolPerformanceCreateInfoKHR";
1566       case StructureType::ePerformanceQuerySubmitInfoKHR : return "PerformanceQuerySubmitInfoKHR";
1567       case StructureType::eAcquireProfilingLockInfoKHR : return "AcquireProfilingLockInfoKHR";
1568       case StructureType::ePerformanceCounterKHR : return "PerformanceCounterKHR";
1569       case StructureType::ePerformanceCounterDescriptionKHR : return "PerformanceCounterDescriptionKHR";
1570       case StructureType::ePerformanceQueryReservationInfoKHR : return "PerformanceQueryReservationInfoKHR";
1571       case StructureType::ePhysicalDeviceSurfaceInfo2KHR : return "PhysicalDeviceSurfaceInfo2KHR";
1572       case StructureType::eSurfaceCapabilities2KHR : return "SurfaceCapabilities2KHR";
1573       case StructureType::eSurfaceFormat2KHR : return "SurfaceFormat2KHR";
1574       case StructureType::eDisplayProperties2KHR : return "DisplayProperties2KHR";
1575       case StructureType::eDisplayPlaneProperties2KHR : return "DisplayPlaneProperties2KHR";
1576       case StructureType::eDisplayModeProperties2KHR : return "DisplayModeProperties2KHR";
1577       case StructureType::eDisplayPlaneInfo2KHR : return "DisplayPlaneInfo2KHR";
1578       case StructureType::eDisplayPlaneCapabilities2KHR : return "DisplayPlaneCapabilities2KHR";
1579       case StructureType::eDebugUtilsObjectNameInfoEXT : return "DebugUtilsObjectNameInfoEXT";
1580       case StructureType::eDebugUtilsObjectTagInfoEXT : return "DebugUtilsObjectTagInfoEXT";
1581       case StructureType::eDebugUtilsLabelEXT : return "DebugUtilsLabelEXT";
1582       case StructureType::eDebugUtilsMessengerCallbackDataEXT : return "DebugUtilsMessengerCallbackDataEXT";
1583       case StructureType::eDebugUtilsMessengerCreateInfoEXT : return "DebugUtilsMessengerCreateInfoEXT";
1584       case StructureType::eSampleLocationsInfoEXT : return "SampleLocationsInfoEXT";
1585       case StructureType::eRenderPassSampleLocationsBeginInfoEXT : return "RenderPassSampleLocationsBeginInfoEXT";
1586       case StructureType::ePipelineSampleLocationsStateCreateInfoEXT : return "PipelineSampleLocationsStateCreateInfoEXT";
1587       case StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT : return "PhysicalDeviceSampleLocationsPropertiesEXT";
1588       case StructureType::eMultisamplePropertiesEXT : return "MultisamplePropertiesEXT";
1589       case StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT : return "PhysicalDeviceBlendOperationAdvancedFeaturesEXT";
1590       case StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT : return "PhysicalDeviceBlendOperationAdvancedPropertiesEXT";
1591       case StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT : return "PipelineColorBlendAdvancedStateCreateInfoEXT";
1592       case StructureType::eDrmFormatModifierPropertiesListEXT : return "DrmFormatModifierPropertiesListEXT";
1593       case StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT : return "PhysicalDeviceImageDrmFormatModifierInfoEXT";
1594       case StructureType::eImageDrmFormatModifierListCreateInfoEXT : return "ImageDrmFormatModifierListCreateInfoEXT";
1595       case StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT : return "ImageDrmFormatModifierExplicitCreateInfoEXT";
1596       case StructureType::eImageDrmFormatModifierPropertiesEXT : return "ImageDrmFormatModifierPropertiesEXT";
1597       case StructureType::eDrmFormatModifierPropertiesList2EXT : return "DrmFormatModifierPropertiesList2EXT";
1598       case StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT : return "PhysicalDeviceImageViewImageFormatInfoEXT";
1599       case StructureType::eFilterCubicImageViewImageFormatPropertiesEXT : return "FilterCubicImageViewImageFormatPropertiesEXT";
1600       case StructureType::eImportMemoryHostPointerInfoEXT : return "ImportMemoryHostPointerInfoEXT";
1601       case StructureType::eMemoryHostPointerPropertiesEXT : return "MemoryHostPointerPropertiesEXT";
1602       case StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT : return "PhysicalDeviceExternalMemoryHostPropertiesEXT";
1603       case StructureType::ePhysicalDeviceShaderClockFeaturesKHR : return "PhysicalDeviceShaderClockFeaturesKHR";
1604       case StructureType::eCalibratedTimestampInfoEXT : return "CalibratedTimestampInfoEXT";
1605       case StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT : return "PhysicalDeviceVertexAttributeDivisorPropertiesEXT";
1606       case StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT : return "PipelineVertexInputDivisorStateCreateInfoEXT";
1607       case StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT : return "PhysicalDeviceVertexAttributeDivisorFeaturesEXT";
1608       case StructureType::ePhysicalDevicePciBusInfoPropertiesEXT : return "PhysicalDevicePciBusInfoPropertiesEXT";
1609       case StructureType::eFragmentShadingRateAttachmentInfoKHR : return "FragmentShadingRateAttachmentInfoKHR";
1610       case StructureType::ePipelineFragmentShadingRateStateCreateInfoKHR : return "PipelineFragmentShadingRateStateCreateInfoKHR";
1611       case StructureType::ePhysicalDeviceFragmentShadingRatePropertiesKHR : return "PhysicalDeviceFragmentShadingRatePropertiesKHR";
1612       case StructureType::ePhysicalDeviceFragmentShadingRateFeaturesKHR : return "PhysicalDeviceFragmentShadingRateFeaturesKHR";
1613       case StructureType::ePhysicalDeviceFragmentShadingRateKHR : return "PhysicalDeviceFragmentShadingRateKHR";
1614       case StructureType::ePhysicalDeviceShaderImageAtomicInt64FeaturesEXT : return "PhysicalDeviceShaderImageAtomicInt64FeaturesEXT";
1615       case StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT : return "PhysicalDeviceMemoryBudgetPropertiesEXT";
1616       case StructureType::eValidationFeaturesEXT : return "ValidationFeaturesEXT";
1617       case StructureType::ePhysicalDeviceFragmentShaderInterlockFeaturesEXT : return "PhysicalDeviceFragmentShaderInterlockFeaturesEXT";
1618       case StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT : return "PhysicalDeviceYcbcrImageArraysFeaturesEXT";
1619       case StructureType::eHeadlessSurfaceCreateInfoEXT : return "HeadlessSurfaceCreateInfoEXT";
1620       case StructureType::ePhysicalDeviceLineRasterizationFeaturesEXT : return "PhysicalDeviceLineRasterizationFeaturesEXT";
1621       case StructureType::ePipelineRasterizationLineStateCreateInfoEXT : return "PipelineRasterizationLineStateCreateInfoEXT";
1622       case StructureType::ePhysicalDeviceLineRasterizationPropertiesEXT : return "PhysicalDeviceLineRasterizationPropertiesEXT";
1623       case StructureType::ePhysicalDeviceShaderAtomicFloatFeaturesEXT : return "PhysicalDeviceShaderAtomicFloatFeaturesEXT";
1624       case StructureType::ePhysicalDeviceIndexTypeUint8FeaturesEXT : return "PhysicalDeviceIndexTypeUint8FeaturesEXT";
1625       case StructureType::ePhysicalDeviceExtendedDynamicStateFeaturesEXT : return "PhysicalDeviceExtendedDynamicStateFeaturesEXT";
1626       case StructureType::ePhysicalDeviceTexelBufferAlignmentFeaturesEXT : return "PhysicalDeviceTexelBufferAlignmentFeaturesEXT";
1627       case StructureType::ePhysicalDeviceRobustness2FeaturesEXT : return "PhysicalDeviceRobustness2FeaturesEXT";
1628       case StructureType::ePhysicalDeviceRobustness2PropertiesEXT : return "PhysicalDeviceRobustness2PropertiesEXT";
1629       case StructureType::eSamplerCustomBorderColorCreateInfoEXT : return "SamplerCustomBorderColorCreateInfoEXT";
1630       case StructureType::ePhysicalDeviceCustomBorderColorPropertiesEXT : return "PhysicalDeviceCustomBorderColorPropertiesEXT";
1631       case StructureType::ePhysicalDeviceCustomBorderColorFeaturesEXT : return "PhysicalDeviceCustomBorderColorFeaturesEXT";
1632       case StructureType::eRefreshObjectListKHR : return "RefreshObjectListKHR";
1633       case StructureType::eQueueFamilyCheckpointProperties2NV : return "QueueFamilyCheckpointProperties2NV";
1634       case StructureType::eCheckpointData2NV : return "CheckpointData2NV";
1635       case StructureType::ePhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT : return "PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT";
1636       case StructureType::ePhysicalDevice4444FormatsFeaturesEXT : return "PhysicalDevice4444FormatsFeaturesEXT";
1637       case StructureType::ePhysicalDeviceVertexInputDynamicStateFeaturesEXT : return "PhysicalDeviceVertexInputDynamicStateFeaturesEXT";
1638       case StructureType::eVertexInputBindingDescription2EXT : return "VertexInputBindingDescription2EXT";
1639       case StructureType::eVertexInputAttributeDescription2EXT : return "VertexInputAttributeDescription2EXT";
1640 #if defined( VK_USE_PLATFORM_SCI )
1641       case StructureType::eImportFenceSciSyncInfoNV : return "ImportFenceSciSyncInfoNV";
1642       case StructureType::eExportFenceSciSyncInfoNV : return "ExportFenceSciSyncInfoNV";
1643       case StructureType::eFenceGetSciSyncInfoNV : return "FenceGetSciSyncInfoNV";
1644       case StructureType::eSciSyncAttributesInfoNV : return "SciSyncAttributesInfoNV";
1645       case StructureType::eImportSemaphoreSciSyncInfoNV : return "ImportSemaphoreSciSyncInfoNV";
1646       case StructureType::eExportSemaphoreSciSyncInfoNV : return "ExportSemaphoreSciSyncInfoNV";
1647       case StructureType::eSemaphoreGetSciSyncInfoNV : return "SemaphoreGetSciSyncInfoNV";
1648       case StructureType::ePhysicalDeviceExternalSciSyncFeaturesNV : return "PhysicalDeviceExternalSciSyncFeaturesNV";
1649       case StructureType::eImportMemorySciBufInfoNV : return "ImportMemorySciBufInfoNV";
1650       case StructureType::eExportMemorySciBufInfoNV : return "ExportMemorySciBufInfoNV";
1651       case StructureType::eMemoryGetSciBufInfoNV : return "MemoryGetSciBufInfoNV";
1652       case StructureType::eMemorySciBufPropertiesNV : return "MemorySciBufPropertiesNV";
1653       case StructureType::ePhysicalDeviceExternalMemorySciBufFeaturesNV : return "PhysicalDeviceExternalMemorySciBufFeaturesNV";
1654 #endif /*VK_USE_PLATFORM_SCI*/
1655       case StructureType::ePhysicalDeviceExtendedDynamicState2FeaturesEXT : return "PhysicalDeviceExtendedDynamicState2FeaturesEXT";
1656       case StructureType::ePhysicalDeviceColorWriteEnableFeaturesEXT : return "PhysicalDeviceColorWriteEnableFeaturesEXT";
1657       case StructureType::ePipelineColorWriteCreateInfoEXT : return "PipelineColorWriteCreateInfoEXT";
1658       case StructureType::eApplicationParametersEXT : return "ApplicationParametersEXT";
1659 #if defined( VK_USE_PLATFORM_SCI )
1660       case StructureType::eSemaphoreSciSyncPoolCreateInfoNV : return "SemaphoreSciSyncPoolCreateInfoNV";
1661       case StructureType::eSemaphoreSciSyncCreateInfoNV : return "SemaphoreSciSyncCreateInfoNV";
1662       case StructureType::ePhysicalDeviceExternalSciSync2FeaturesNV : return "PhysicalDeviceExternalSciSync2FeaturesNV";
1663       case StructureType::eDeviceSemaphoreSciSyncPoolReservationCreateInfoNV : return "DeviceSemaphoreSciSyncPoolReservationCreateInfoNV";
1664 #endif /*VK_USE_PLATFORM_SCI*/
1665 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
1666       case StructureType::eScreenBufferPropertiesQNX : return "ScreenBufferPropertiesQNX";
1667       case StructureType::eScreenBufferFormatPropertiesQNX : return "ScreenBufferFormatPropertiesQNX";
1668       case StructureType::eImportScreenBufferInfoQNX : return "ImportScreenBufferInfoQNX";
1669       case StructureType::eExternalFormatQNX : return "ExternalFormatQNX";
1670       case StructureType::ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX : return "PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX";
1671 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
1672       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
1673     }
1674 
1675   }
1676 
1677 
to_string(PipelineCacheHeaderVersion value)1678   VULKAN_HPP_INLINE std::string to_string( PipelineCacheHeaderVersion value )
1679   {
1680     switch ( value )
1681     {
1682       case PipelineCacheHeaderVersion::eOne : return "One";
1683       case PipelineCacheHeaderVersion::eSafetyCriticalOne : return "SafetyCriticalOne";
1684       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
1685     }
1686 
1687   }
1688 
1689 
to_string(ObjectType value)1690   VULKAN_HPP_INLINE std::string to_string( ObjectType value )
1691   {
1692     switch ( value )
1693     {
1694       case ObjectType::eUnknown : return "Unknown";
1695       case ObjectType::eInstance : return "Instance";
1696       case ObjectType::ePhysicalDevice : return "PhysicalDevice";
1697       case ObjectType::eDevice : return "Device";
1698       case ObjectType::eQueue : return "Queue";
1699       case ObjectType::eSemaphore : return "Semaphore";
1700       case ObjectType::eCommandBuffer : return "CommandBuffer";
1701       case ObjectType::eFence : return "Fence";
1702       case ObjectType::eDeviceMemory : return "DeviceMemory";
1703       case ObjectType::eBuffer : return "Buffer";
1704       case ObjectType::eImage : return "Image";
1705       case ObjectType::eEvent : return "Event";
1706       case ObjectType::eQueryPool : return "QueryPool";
1707       case ObjectType::eBufferView : return "BufferView";
1708       case ObjectType::eImageView : return "ImageView";
1709       case ObjectType::eShaderModule : return "ShaderModule";
1710       case ObjectType::ePipelineCache : return "PipelineCache";
1711       case ObjectType::ePipelineLayout : return "PipelineLayout";
1712       case ObjectType::eRenderPass : return "RenderPass";
1713       case ObjectType::ePipeline : return "Pipeline";
1714       case ObjectType::eDescriptorSetLayout : return "DescriptorSetLayout";
1715       case ObjectType::eSampler : return "Sampler";
1716       case ObjectType::eDescriptorPool : return "DescriptorPool";
1717       case ObjectType::eDescriptorSet : return "DescriptorSet";
1718       case ObjectType::eFramebuffer : return "Framebuffer";
1719       case ObjectType::eCommandPool : return "CommandPool";
1720       case ObjectType::eSamplerYcbcrConversion : return "SamplerYcbcrConversion";
1721       case ObjectType::ePrivateDataSlot : return "PrivateDataSlot";
1722       case ObjectType::eSurfaceKHR : return "SurfaceKHR";
1723       case ObjectType::eSwapchainKHR : return "SwapchainKHR";
1724       case ObjectType::eDisplayKHR : return "DisplayKHR";
1725       case ObjectType::eDisplayModeKHR : return "DisplayModeKHR";
1726       case ObjectType::eDebugUtilsMessengerEXT : return "DebugUtilsMessengerEXT";
1727 #if defined( VK_USE_PLATFORM_SCI )
1728       case ObjectType::eSemaphoreSciSyncPoolNV : return "SemaphoreSciSyncPoolNV";
1729 #endif /*VK_USE_PLATFORM_SCI*/
1730       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
1731     }
1732 
1733   }
1734 
1735 
to_string(VendorId value)1736   VULKAN_HPP_INLINE std::string to_string( VendorId value )
1737   {
1738     switch ( value )
1739     {
1740       case VendorId::eVIV : return "VIV";
1741       case VendorId::eVSI : return "VSI";
1742       case VendorId::eKazan : return "Kazan";
1743       case VendorId::eCodeplay : return "Codeplay";
1744       case VendorId::eMESA : return "MESA";
1745       case VendorId::ePocl : return "Pocl";
1746       case VendorId::eMobileye : return "Mobileye";
1747       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
1748     }
1749 
1750   }
1751 
1752 
to_string(Format value)1753   VULKAN_HPP_INLINE std::string to_string( Format value )
1754   {
1755     switch ( value )
1756     {
1757       case Format::eUndefined : return "Undefined";
1758       case Format::eR4G4UnormPack8 : return "R4G4UnormPack8";
1759       case Format::eR4G4B4A4UnormPack16 : return "R4G4B4A4UnormPack16";
1760       case Format::eB4G4R4A4UnormPack16 : return "B4G4R4A4UnormPack16";
1761       case Format::eR5G6B5UnormPack16 : return "R5G6B5UnormPack16";
1762       case Format::eB5G6R5UnormPack16 : return "B5G6R5UnormPack16";
1763       case Format::eR5G5B5A1UnormPack16 : return "R5G5B5A1UnormPack16";
1764       case Format::eB5G5R5A1UnormPack16 : return "B5G5R5A1UnormPack16";
1765       case Format::eA1R5G5B5UnormPack16 : return "A1R5G5B5UnormPack16";
1766       case Format::eR8Unorm : return "R8Unorm";
1767       case Format::eR8Snorm : return "R8Snorm";
1768       case Format::eR8Uscaled : return "R8Uscaled";
1769       case Format::eR8Sscaled : return "R8Sscaled";
1770       case Format::eR8Uint : return "R8Uint";
1771       case Format::eR8Sint : return "R8Sint";
1772       case Format::eR8Srgb : return "R8Srgb";
1773       case Format::eR8G8Unorm : return "R8G8Unorm";
1774       case Format::eR8G8Snorm : return "R8G8Snorm";
1775       case Format::eR8G8Uscaled : return "R8G8Uscaled";
1776       case Format::eR8G8Sscaled : return "R8G8Sscaled";
1777       case Format::eR8G8Uint : return "R8G8Uint";
1778       case Format::eR8G8Sint : return "R8G8Sint";
1779       case Format::eR8G8Srgb : return "R8G8Srgb";
1780       case Format::eR8G8B8Unorm : return "R8G8B8Unorm";
1781       case Format::eR8G8B8Snorm : return "R8G8B8Snorm";
1782       case Format::eR8G8B8Uscaled : return "R8G8B8Uscaled";
1783       case Format::eR8G8B8Sscaled : return "R8G8B8Sscaled";
1784       case Format::eR8G8B8Uint : return "R8G8B8Uint";
1785       case Format::eR8G8B8Sint : return "R8G8B8Sint";
1786       case Format::eR8G8B8Srgb : return "R8G8B8Srgb";
1787       case Format::eB8G8R8Unorm : return "B8G8R8Unorm";
1788       case Format::eB8G8R8Snorm : return "B8G8R8Snorm";
1789       case Format::eB8G8R8Uscaled : return "B8G8R8Uscaled";
1790       case Format::eB8G8R8Sscaled : return "B8G8R8Sscaled";
1791       case Format::eB8G8R8Uint : return "B8G8R8Uint";
1792       case Format::eB8G8R8Sint : return "B8G8R8Sint";
1793       case Format::eB8G8R8Srgb : return "B8G8R8Srgb";
1794       case Format::eR8G8B8A8Unorm : return "R8G8B8A8Unorm";
1795       case Format::eR8G8B8A8Snorm : return "R8G8B8A8Snorm";
1796       case Format::eR8G8B8A8Uscaled : return "R8G8B8A8Uscaled";
1797       case Format::eR8G8B8A8Sscaled : return "R8G8B8A8Sscaled";
1798       case Format::eR8G8B8A8Uint : return "R8G8B8A8Uint";
1799       case Format::eR8G8B8A8Sint : return "R8G8B8A8Sint";
1800       case Format::eR8G8B8A8Srgb : return "R8G8B8A8Srgb";
1801       case Format::eB8G8R8A8Unorm : return "B8G8R8A8Unorm";
1802       case Format::eB8G8R8A8Snorm : return "B8G8R8A8Snorm";
1803       case Format::eB8G8R8A8Uscaled : return "B8G8R8A8Uscaled";
1804       case Format::eB8G8R8A8Sscaled : return "B8G8R8A8Sscaled";
1805       case Format::eB8G8R8A8Uint : return "B8G8R8A8Uint";
1806       case Format::eB8G8R8A8Sint : return "B8G8R8A8Sint";
1807       case Format::eB8G8R8A8Srgb : return "B8G8R8A8Srgb";
1808       case Format::eA8B8G8R8UnormPack32 : return "A8B8G8R8UnormPack32";
1809       case Format::eA8B8G8R8SnormPack32 : return "A8B8G8R8SnormPack32";
1810       case Format::eA8B8G8R8UscaledPack32 : return "A8B8G8R8UscaledPack32";
1811       case Format::eA8B8G8R8SscaledPack32 : return "A8B8G8R8SscaledPack32";
1812       case Format::eA8B8G8R8UintPack32 : return "A8B8G8R8UintPack32";
1813       case Format::eA8B8G8R8SintPack32 : return "A8B8G8R8SintPack32";
1814       case Format::eA8B8G8R8SrgbPack32 : return "A8B8G8R8SrgbPack32";
1815       case Format::eA2R10G10B10UnormPack32 : return "A2R10G10B10UnormPack32";
1816       case Format::eA2R10G10B10SnormPack32 : return "A2R10G10B10SnormPack32";
1817       case Format::eA2R10G10B10UscaledPack32 : return "A2R10G10B10UscaledPack32";
1818       case Format::eA2R10G10B10SscaledPack32 : return "A2R10G10B10SscaledPack32";
1819       case Format::eA2R10G10B10UintPack32 : return "A2R10G10B10UintPack32";
1820       case Format::eA2R10G10B10SintPack32 : return "A2R10G10B10SintPack32";
1821       case Format::eA2B10G10R10UnormPack32 : return "A2B10G10R10UnormPack32";
1822       case Format::eA2B10G10R10SnormPack32 : return "A2B10G10R10SnormPack32";
1823       case Format::eA2B10G10R10UscaledPack32 : return "A2B10G10R10UscaledPack32";
1824       case Format::eA2B10G10R10SscaledPack32 : return "A2B10G10R10SscaledPack32";
1825       case Format::eA2B10G10R10UintPack32 : return "A2B10G10R10UintPack32";
1826       case Format::eA2B10G10R10SintPack32 : return "A2B10G10R10SintPack32";
1827       case Format::eR16Unorm : return "R16Unorm";
1828       case Format::eR16Snorm : return "R16Snorm";
1829       case Format::eR16Uscaled : return "R16Uscaled";
1830       case Format::eR16Sscaled : return "R16Sscaled";
1831       case Format::eR16Uint : return "R16Uint";
1832       case Format::eR16Sint : return "R16Sint";
1833       case Format::eR16Sfloat : return "R16Sfloat";
1834       case Format::eR16G16Unorm : return "R16G16Unorm";
1835       case Format::eR16G16Snorm : return "R16G16Snorm";
1836       case Format::eR16G16Uscaled : return "R16G16Uscaled";
1837       case Format::eR16G16Sscaled : return "R16G16Sscaled";
1838       case Format::eR16G16Uint : return "R16G16Uint";
1839       case Format::eR16G16Sint : return "R16G16Sint";
1840       case Format::eR16G16Sfloat : return "R16G16Sfloat";
1841       case Format::eR16G16B16Unorm : return "R16G16B16Unorm";
1842       case Format::eR16G16B16Snorm : return "R16G16B16Snorm";
1843       case Format::eR16G16B16Uscaled : return "R16G16B16Uscaled";
1844       case Format::eR16G16B16Sscaled : return "R16G16B16Sscaled";
1845       case Format::eR16G16B16Uint : return "R16G16B16Uint";
1846       case Format::eR16G16B16Sint : return "R16G16B16Sint";
1847       case Format::eR16G16B16Sfloat : return "R16G16B16Sfloat";
1848       case Format::eR16G16B16A16Unorm : return "R16G16B16A16Unorm";
1849       case Format::eR16G16B16A16Snorm : return "R16G16B16A16Snorm";
1850       case Format::eR16G16B16A16Uscaled : return "R16G16B16A16Uscaled";
1851       case Format::eR16G16B16A16Sscaled : return "R16G16B16A16Sscaled";
1852       case Format::eR16G16B16A16Uint : return "R16G16B16A16Uint";
1853       case Format::eR16G16B16A16Sint : return "R16G16B16A16Sint";
1854       case Format::eR16G16B16A16Sfloat : return "R16G16B16A16Sfloat";
1855       case Format::eR32Uint : return "R32Uint";
1856       case Format::eR32Sint : return "R32Sint";
1857       case Format::eR32Sfloat : return "R32Sfloat";
1858       case Format::eR32G32Uint : return "R32G32Uint";
1859       case Format::eR32G32Sint : return "R32G32Sint";
1860       case Format::eR32G32Sfloat : return "R32G32Sfloat";
1861       case Format::eR32G32B32Uint : return "R32G32B32Uint";
1862       case Format::eR32G32B32Sint : return "R32G32B32Sint";
1863       case Format::eR32G32B32Sfloat : return "R32G32B32Sfloat";
1864       case Format::eR32G32B32A32Uint : return "R32G32B32A32Uint";
1865       case Format::eR32G32B32A32Sint : return "R32G32B32A32Sint";
1866       case Format::eR32G32B32A32Sfloat : return "R32G32B32A32Sfloat";
1867       case Format::eR64Uint : return "R64Uint";
1868       case Format::eR64Sint : return "R64Sint";
1869       case Format::eR64Sfloat : return "R64Sfloat";
1870       case Format::eR64G64Uint : return "R64G64Uint";
1871       case Format::eR64G64Sint : return "R64G64Sint";
1872       case Format::eR64G64Sfloat : return "R64G64Sfloat";
1873       case Format::eR64G64B64Uint : return "R64G64B64Uint";
1874       case Format::eR64G64B64Sint : return "R64G64B64Sint";
1875       case Format::eR64G64B64Sfloat : return "R64G64B64Sfloat";
1876       case Format::eR64G64B64A64Uint : return "R64G64B64A64Uint";
1877       case Format::eR64G64B64A64Sint : return "R64G64B64A64Sint";
1878       case Format::eR64G64B64A64Sfloat : return "R64G64B64A64Sfloat";
1879       case Format::eB10G11R11UfloatPack32 : return "B10G11R11UfloatPack32";
1880       case Format::eE5B9G9R9UfloatPack32 : return "E5B9G9R9UfloatPack32";
1881       case Format::eD16Unorm : return "D16Unorm";
1882       case Format::eX8D24UnormPack32 : return "X8D24UnormPack32";
1883       case Format::eD32Sfloat : return "D32Sfloat";
1884       case Format::eS8Uint : return "S8Uint";
1885       case Format::eD16UnormS8Uint : return "D16UnormS8Uint";
1886       case Format::eD24UnormS8Uint : return "D24UnormS8Uint";
1887       case Format::eD32SfloatS8Uint : return "D32SfloatS8Uint";
1888       case Format::eBc1RgbUnormBlock : return "Bc1RgbUnormBlock";
1889       case Format::eBc1RgbSrgbBlock : return "Bc1RgbSrgbBlock";
1890       case Format::eBc1RgbaUnormBlock : return "Bc1RgbaUnormBlock";
1891       case Format::eBc1RgbaSrgbBlock : return "Bc1RgbaSrgbBlock";
1892       case Format::eBc2UnormBlock : return "Bc2UnormBlock";
1893       case Format::eBc2SrgbBlock : return "Bc2SrgbBlock";
1894       case Format::eBc3UnormBlock : return "Bc3UnormBlock";
1895       case Format::eBc3SrgbBlock : return "Bc3SrgbBlock";
1896       case Format::eBc4UnormBlock : return "Bc4UnormBlock";
1897       case Format::eBc4SnormBlock : return "Bc4SnormBlock";
1898       case Format::eBc5UnormBlock : return "Bc5UnormBlock";
1899       case Format::eBc5SnormBlock : return "Bc5SnormBlock";
1900       case Format::eBc6HUfloatBlock : return "Bc6HUfloatBlock";
1901       case Format::eBc6HSfloatBlock : return "Bc6HSfloatBlock";
1902       case Format::eBc7UnormBlock : return "Bc7UnormBlock";
1903       case Format::eBc7SrgbBlock : return "Bc7SrgbBlock";
1904       case Format::eEtc2R8G8B8UnormBlock : return "Etc2R8G8B8UnormBlock";
1905       case Format::eEtc2R8G8B8SrgbBlock : return "Etc2R8G8B8SrgbBlock";
1906       case Format::eEtc2R8G8B8A1UnormBlock : return "Etc2R8G8B8A1UnormBlock";
1907       case Format::eEtc2R8G8B8A1SrgbBlock : return "Etc2R8G8B8A1SrgbBlock";
1908       case Format::eEtc2R8G8B8A8UnormBlock : return "Etc2R8G8B8A8UnormBlock";
1909       case Format::eEtc2R8G8B8A8SrgbBlock : return "Etc2R8G8B8A8SrgbBlock";
1910       case Format::eEacR11UnormBlock : return "EacR11UnormBlock";
1911       case Format::eEacR11SnormBlock : return "EacR11SnormBlock";
1912       case Format::eEacR11G11UnormBlock : return "EacR11G11UnormBlock";
1913       case Format::eEacR11G11SnormBlock : return "EacR11G11SnormBlock";
1914       case Format::eAstc4x4UnormBlock : return "Astc4x4UnormBlock";
1915       case Format::eAstc4x4SrgbBlock : return "Astc4x4SrgbBlock";
1916       case Format::eAstc5x4UnormBlock : return "Astc5x4UnormBlock";
1917       case Format::eAstc5x4SrgbBlock : return "Astc5x4SrgbBlock";
1918       case Format::eAstc5x5UnormBlock : return "Astc5x5UnormBlock";
1919       case Format::eAstc5x5SrgbBlock : return "Astc5x5SrgbBlock";
1920       case Format::eAstc6x5UnormBlock : return "Astc6x5UnormBlock";
1921       case Format::eAstc6x5SrgbBlock : return "Astc6x5SrgbBlock";
1922       case Format::eAstc6x6UnormBlock : return "Astc6x6UnormBlock";
1923       case Format::eAstc6x6SrgbBlock : return "Astc6x6SrgbBlock";
1924       case Format::eAstc8x5UnormBlock : return "Astc8x5UnormBlock";
1925       case Format::eAstc8x5SrgbBlock : return "Astc8x5SrgbBlock";
1926       case Format::eAstc8x6UnormBlock : return "Astc8x6UnormBlock";
1927       case Format::eAstc8x6SrgbBlock : return "Astc8x6SrgbBlock";
1928       case Format::eAstc8x8UnormBlock : return "Astc8x8UnormBlock";
1929       case Format::eAstc8x8SrgbBlock : return "Astc8x8SrgbBlock";
1930       case Format::eAstc10x5UnormBlock : return "Astc10x5UnormBlock";
1931       case Format::eAstc10x5SrgbBlock : return "Astc10x5SrgbBlock";
1932       case Format::eAstc10x6UnormBlock : return "Astc10x6UnormBlock";
1933       case Format::eAstc10x6SrgbBlock : return "Astc10x6SrgbBlock";
1934       case Format::eAstc10x8UnormBlock : return "Astc10x8UnormBlock";
1935       case Format::eAstc10x8SrgbBlock : return "Astc10x8SrgbBlock";
1936       case Format::eAstc10x10UnormBlock : return "Astc10x10UnormBlock";
1937       case Format::eAstc10x10SrgbBlock : return "Astc10x10SrgbBlock";
1938       case Format::eAstc12x10UnormBlock : return "Astc12x10UnormBlock";
1939       case Format::eAstc12x10SrgbBlock : return "Astc12x10SrgbBlock";
1940       case Format::eAstc12x12UnormBlock : return "Astc12x12UnormBlock";
1941       case Format::eAstc12x12SrgbBlock : return "Astc12x12SrgbBlock";
1942       case Format::eG8B8G8R8422Unorm : return "G8B8G8R8422Unorm";
1943       case Format::eB8G8R8G8422Unorm : return "B8G8R8G8422Unorm";
1944       case Format::eG8B8R83Plane420Unorm : return "G8B8R83Plane420Unorm";
1945       case Format::eG8B8R82Plane420Unorm : return "G8B8R82Plane420Unorm";
1946       case Format::eG8B8R83Plane422Unorm : return "G8B8R83Plane422Unorm";
1947       case Format::eG8B8R82Plane422Unorm : return "G8B8R82Plane422Unorm";
1948       case Format::eG8B8R83Plane444Unorm : return "G8B8R83Plane444Unorm";
1949       case Format::eR10X6UnormPack16 : return "R10X6UnormPack16";
1950       case Format::eR10X6G10X6Unorm2Pack16 : return "R10X6G10X6Unorm2Pack16";
1951       case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16 : return "R10X6G10X6B10X6A10X6Unorm4Pack16";
1952       case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16 : return "G10X6B10X6G10X6R10X6422Unorm4Pack16";
1953       case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16 : return "B10X6G10X6R10X6G10X6422Unorm4Pack16";
1954       case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16 : return "G10X6B10X6R10X63Plane420Unorm3Pack16";
1955       case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16 : return "G10X6B10X6R10X62Plane420Unorm3Pack16";
1956       case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16 : return "G10X6B10X6R10X63Plane422Unorm3Pack16";
1957       case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16 : return "G10X6B10X6R10X62Plane422Unorm3Pack16";
1958       case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16 : return "G10X6B10X6R10X63Plane444Unorm3Pack16";
1959       case Format::eR12X4UnormPack16 : return "R12X4UnormPack16";
1960       case Format::eR12X4G12X4Unorm2Pack16 : return "R12X4G12X4Unorm2Pack16";
1961       case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16 : return "R12X4G12X4B12X4A12X4Unorm4Pack16";
1962       case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16 : return "G12X4B12X4G12X4R12X4422Unorm4Pack16";
1963       case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16 : return "B12X4G12X4R12X4G12X4422Unorm4Pack16";
1964       case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16 : return "G12X4B12X4R12X43Plane420Unorm3Pack16";
1965       case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16 : return "G12X4B12X4R12X42Plane420Unorm3Pack16";
1966       case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16 : return "G12X4B12X4R12X43Plane422Unorm3Pack16";
1967       case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16 : return "G12X4B12X4R12X42Plane422Unorm3Pack16";
1968       case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16 : return "G12X4B12X4R12X43Plane444Unorm3Pack16";
1969       case Format::eG16B16G16R16422Unorm : return "G16B16G16R16422Unorm";
1970       case Format::eB16G16R16G16422Unorm : return "B16G16R16G16422Unorm";
1971       case Format::eG16B16R163Plane420Unorm : return "G16B16R163Plane420Unorm";
1972       case Format::eG16B16R162Plane420Unorm : return "G16B16R162Plane420Unorm";
1973       case Format::eG16B16R163Plane422Unorm : return "G16B16R163Plane422Unorm";
1974       case Format::eG16B16R162Plane422Unorm : return "G16B16R162Plane422Unorm";
1975       case Format::eG16B16R163Plane444Unorm : return "G16B16R163Plane444Unorm";
1976       case Format::eG8B8R82Plane444Unorm : return "G8B8R82Plane444Unorm";
1977       case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16 : return "G10X6B10X6R10X62Plane444Unorm3Pack16";
1978       case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16 : return "G12X4B12X4R12X42Plane444Unorm3Pack16";
1979       case Format::eG16B16R162Plane444Unorm : return "G16B16R162Plane444Unorm";
1980       case Format::eA4R4G4B4UnormPack16 : return "A4R4G4B4UnormPack16";
1981       case Format::eA4B4G4R4UnormPack16 : return "A4B4G4R4UnormPack16";
1982       case Format::eAstc4x4SfloatBlock : return "Astc4x4SfloatBlock";
1983       case Format::eAstc5x4SfloatBlock : return "Astc5x4SfloatBlock";
1984       case Format::eAstc5x5SfloatBlock : return "Astc5x5SfloatBlock";
1985       case Format::eAstc6x5SfloatBlock : return "Astc6x5SfloatBlock";
1986       case Format::eAstc6x6SfloatBlock : return "Astc6x6SfloatBlock";
1987       case Format::eAstc8x5SfloatBlock : return "Astc8x5SfloatBlock";
1988       case Format::eAstc8x6SfloatBlock : return "Astc8x6SfloatBlock";
1989       case Format::eAstc8x8SfloatBlock : return "Astc8x8SfloatBlock";
1990       case Format::eAstc10x5SfloatBlock : return "Astc10x5SfloatBlock";
1991       case Format::eAstc10x6SfloatBlock : return "Astc10x6SfloatBlock";
1992       case Format::eAstc10x8SfloatBlock : return "Astc10x8SfloatBlock";
1993       case Format::eAstc10x10SfloatBlock : return "Astc10x10SfloatBlock";
1994       case Format::eAstc12x10SfloatBlock : return "Astc12x10SfloatBlock";
1995       case Format::eAstc12x12SfloatBlock : return "Astc12x12SfloatBlock";
1996       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
1997     }
1998 
1999   }
2000 
2001 
to_string(FormatFeatureFlagBits value)2002   VULKAN_HPP_INLINE std::string to_string( FormatFeatureFlagBits value )
2003   {
2004     switch ( value )
2005     {
2006       case FormatFeatureFlagBits::eSampledImage : return "SampledImage";
2007       case FormatFeatureFlagBits::eStorageImage : return "StorageImage";
2008       case FormatFeatureFlagBits::eStorageImageAtomic : return "StorageImageAtomic";
2009       case FormatFeatureFlagBits::eUniformTexelBuffer : return "UniformTexelBuffer";
2010       case FormatFeatureFlagBits::eStorageTexelBuffer : return "StorageTexelBuffer";
2011       case FormatFeatureFlagBits::eStorageTexelBufferAtomic : return "StorageTexelBufferAtomic";
2012       case FormatFeatureFlagBits::eVertexBuffer : return "VertexBuffer";
2013       case FormatFeatureFlagBits::eColorAttachment : return "ColorAttachment";
2014       case FormatFeatureFlagBits::eColorAttachmentBlend : return "ColorAttachmentBlend";
2015       case FormatFeatureFlagBits::eDepthStencilAttachment : return "DepthStencilAttachment";
2016       case FormatFeatureFlagBits::eBlitSrc : return "BlitSrc";
2017       case FormatFeatureFlagBits::eBlitDst : return "BlitDst";
2018       case FormatFeatureFlagBits::eSampledImageFilterLinear : return "SampledImageFilterLinear";
2019       case FormatFeatureFlagBits::eTransferSrc : return "TransferSrc";
2020       case FormatFeatureFlagBits::eTransferDst : return "TransferDst";
2021       case FormatFeatureFlagBits::eMidpointChromaSamples : return "MidpointChromaSamples";
2022       case FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter : return "SampledImageYcbcrConversionLinearFilter";
2023       case FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter : return "SampledImageYcbcrConversionSeparateReconstructionFilter";
2024       case FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit : return "SampledImageYcbcrConversionChromaReconstructionExplicit";
2025       case FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable : return "SampledImageYcbcrConversionChromaReconstructionExplicitForceable";
2026       case FormatFeatureFlagBits::eDisjoint : return "Disjoint";
2027       case FormatFeatureFlagBits::eCositedChromaSamples : return "CositedChromaSamples";
2028       case FormatFeatureFlagBits::eSampledImageFilterMinmax : return "SampledImageFilterMinmax";
2029       case FormatFeatureFlagBits::eSampledImageFilterCubicEXT : return "SampledImageFilterCubicEXT";
2030       case FormatFeatureFlagBits::eFragmentShadingRateAttachmentKHR : return "FragmentShadingRateAttachmentKHR";
2031       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2032     }
2033 
2034   }
2035 
2036 
to_string(ImageCreateFlagBits value)2037   VULKAN_HPP_INLINE std::string to_string( ImageCreateFlagBits value )
2038   {
2039     switch ( value )
2040     {
2041       case ImageCreateFlagBits::eSparseBinding : return "SparseBinding";
2042       case ImageCreateFlagBits::eSparseResidency : return "SparseResidency";
2043       case ImageCreateFlagBits::eSparseAliased : return "SparseAliased";
2044       case ImageCreateFlagBits::eMutableFormat : return "MutableFormat";
2045       case ImageCreateFlagBits::eCubeCompatible : return "CubeCompatible";
2046       case ImageCreateFlagBits::eAlias : return "Alias";
2047       case ImageCreateFlagBits::eSplitInstanceBindRegions : return "SplitInstanceBindRegions";
2048       case ImageCreateFlagBits::e2DArrayCompatible : return "2DArrayCompatible";
2049       case ImageCreateFlagBits::eBlockTexelViewCompatible : return "BlockTexelViewCompatible";
2050       case ImageCreateFlagBits::eExtendedUsage : return "ExtendedUsage";
2051       case ImageCreateFlagBits::eProtected : return "Protected";
2052       case ImageCreateFlagBits::eDisjoint : return "Disjoint";
2053       case ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT : return "SampleLocationsCompatibleDepthEXT";
2054       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2055     }
2056 
2057   }
2058 
2059 
to_string(ImageTiling value)2060   VULKAN_HPP_INLINE std::string to_string( ImageTiling value )
2061   {
2062     switch ( value )
2063     {
2064       case ImageTiling::eOptimal : return "Optimal";
2065       case ImageTiling::eLinear : return "Linear";
2066       case ImageTiling::eDrmFormatModifierEXT : return "DrmFormatModifierEXT";
2067       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2068     }
2069 
2070   }
2071 
2072 
to_string(ImageType value)2073   VULKAN_HPP_INLINE std::string to_string( ImageType value )
2074   {
2075     switch ( value )
2076     {
2077       case ImageType::e1D : return "1D";
2078       case ImageType::e2D : return "2D";
2079       case ImageType::e3D : return "3D";
2080       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2081     }
2082 
2083   }
2084 
2085 
to_string(ImageUsageFlagBits value)2086   VULKAN_HPP_INLINE std::string to_string( ImageUsageFlagBits value )
2087   {
2088     switch ( value )
2089     {
2090       case ImageUsageFlagBits::eTransferSrc : return "TransferSrc";
2091       case ImageUsageFlagBits::eTransferDst : return "TransferDst";
2092       case ImageUsageFlagBits::eSampled : return "Sampled";
2093       case ImageUsageFlagBits::eStorage : return "Storage";
2094       case ImageUsageFlagBits::eColorAttachment : return "ColorAttachment";
2095       case ImageUsageFlagBits::eDepthStencilAttachment : return "DepthStencilAttachment";
2096       case ImageUsageFlagBits::eTransientAttachment : return "TransientAttachment";
2097       case ImageUsageFlagBits::eInputAttachment : return "InputAttachment";
2098       case ImageUsageFlagBits::eFragmentShadingRateAttachmentKHR : return "FragmentShadingRateAttachmentKHR";
2099       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2100     }
2101 
2102   }
2103 
2104 
to_string(InstanceCreateFlagBits)2105   VULKAN_HPP_INLINE std::string to_string( InstanceCreateFlagBits )
2106   {
2107     return "(void)";
2108   }
2109 
2110 
to_string(InternalAllocationType value)2111   VULKAN_HPP_INLINE std::string to_string( InternalAllocationType value )
2112   {
2113     switch ( value )
2114     {
2115       case InternalAllocationType::eExecutable : return "Executable";
2116       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2117     }
2118 
2119   }
2120 
2121 
to_string(MemoryHeapFlagBits value)2122   VULKAN_HPP_INLINE std::string to_string( MemoryHeapFlagBits value )
2123   {
2124     switch ( value )
2125     {
2126       case MemoryHeapFlagBits::eDeviceLocal : return "DeviceLocal";
2127       case MemoryHeapFlagBits::eMultiInstance : return "MultiInstance";
2128       case MemoryHeapFlagBits::eSeuSafe : return "SeuSafe";
2129       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2130     }
2131 
2132   }
2133 
2134 
to_string(MemoryPropertyFlagBits value)2135   VULKAN_HPP_INLINE std::string to_string( MemoryPropertyFlagBits value )
2136   {
2137     switch ( value )
2138     {
2139       case MemoryPropertyFlagBits::eDeviceLocal : return "DeviceLocal";
2140       case MemoryPropertyFlagBits::eHostVisible : return "HostVisible";
2141       case MemoryPropertyFlagBits::eHostCoherent : return "HostCoherent";
2142       case MemoryPropertyFlagBits::eHostCached : return "HostCached";
2143       case MemoryPropertyFlagBits::eLazilyAllocated : return "LazilyAllocated";
2144       case MemoryPropertyFlagBits::eProtected : return "Protected";
2145       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2146     }
2147 
2148   }
2149 
2150 
to_string(PhysicalDeviceType value)2151   VULKAN_HPP_INLINE std::string to_string( PhysicalDeviceType value )
2152   {
2153     switch ( value )
2154     {
2155       case PhysicalDeviceType::eOther : return "Other";
2156       case PhysicalDeviceType::eIntegratedGpu : return "IntegratedGpu";
2157       case PhysicalDeviceType::eDiscreteGpu : return "DiscreteGpu";
2158       case PhysicalDeviceType::eVirtualGpu : return "VirtualGpu";
2159       case PhysicalDeviceType::eCpu : return "Cpu";
2160       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2161     }
2162 
2163   }
2164 
2165 
to_string(QueueFlagBits value)2166   VULKAN_HPP_INLINE std::string to_string( QueueFlagBits value )
2167   {
2168     switch ( value )
2169     {
2170       case QueueFlagBits::eGraphics : return "Graphics";
2171       case QueueFlagBits::eCompute : return "Compute";
2172       case QueueFlagBits::eTransfer : return "Transfer";
2173       case QueueFlagBits::eProtected : return "Protected";
2174       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2175     }
2176 
2177   }
2178 
2179 
to_string(SampleCountFlagBits value)2180   VULKAN_HPP_INLINE std::string to_string( SampleCountFlagBits value )
2181   {
2182     switch ( value )
2183     {
2184       case SampleCountFlagBits::e1 : return "1";
2185       case SampleCountFlagBits::e2 : return "2";
2186       case SampleCountFlagBits::e4 : return "4";
2187       case SampleCountFlagBits::e8 : return "8";
2188       case SampleCountFlagBits::e16 : return "16";
2189       case SampleCountFlagBits::e32 : return "32";
2190       case SampleCountFlagBits::e64 : return "64";
2191       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2192     }
2193 
2194   }
2195 
2196 
to_string(SystemAllocationScope value)2197   VULKAN_HPP_INLINE std::string to_string( SystemAllocationScope value )
2198   {
2199     switch ( value )
2200     {
2201       case SystemAllocationScope::eCommand : return "Command";
2202       case SystemAllocationScope::eObject : return "Object";
2203       case SystemAllocationScope::eCache : return "Cache";
2204       case SystemAllocationScope::eDevice : return "Device";
2205       case SystemAllocationScope::eInstance : return "Instance";
2206       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2207     }
2208 
2209   }
2210 
2211 
to_string(DeviceCreateFlagBits)2212   VULKAN_HPP_INLINE std::string to_string( DeviceCreateFlagBits )
2213   {
2214     return "(void)";
2215   }
2216 
2217 
to_string(DeviceQueueCreateFlagBits value)2218   VULKAN_HPP_INLINE std::string to_string( DeviceQueueCreateFlagBits value )
2219   {
2220     switch ( value )
2221     {
2222       case DeviceQueueCreateFlagBits::eProtected : return "Protected";
2223       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2224     }
2225 
2226   }
2227 
2228 
to_string(PipelineStageFlagBits value)2229   VULKAN_HPP_INLINE std::string to_string( PipelineStageFlagBits value )
2230   {
2231     switch ( value )
2232     {
2233       case PipelineStageFlagBits::eTopOfPipe : return "TopOfPipe";
2234       case PipelineStageFlagBits::eDrawIndirect : return "DrawIndirect";
2235       case PipelineStageFlagBits::eVertexInput : return "VertexInput";
2236       case PipelineStageFlagBits::eVertexShader : return "VertexShader";
2237       case PipelineStageFlagBits::eTessellationControlShader : return "TessellationControlShader";
2238       case PipelineStageFlagBits::eTessellationEvaluationShader : return "TessellationEvaluationShader";
2239       case PipelineStageFlagBits::eGeometryShader : return "GeometryShader";
2240       case PipelineStageFlagBits::eFragmentShader : return "FragmentShader";
2241       case PipelineStageFlagBits::eEarlyFragmentTests : return "EarlyFragmentTests";
2242       case PipelineStageFlagBits::eLateFragmentTests : return "LateFragmentTests";
2243       case PipelineStageFlagBits::eColorAttachmentOutput : return "ColorAttachmentOutput";
2244       case PipelineStageFlagBits::eComputeShader : return "ComputeShader";
2245       case PipelineStageFlagBits::eTransfer : return "Transfer";
2246       case PipelineStageFlagBits::eBottomOfPipe : return "BottomOfPipe";
2247       case PipelineStageFlagBits::eHost : return "Host";
2248       case PipelineStageFlagBits::eAllGraphics : return "AllGraphics";
2249       case PipelineStageFlagBits::eAllCommands : return "AllCommands";
2250       case PipelineStageFlagBits::eNone : return "None";
2251       case PipelineStageFlagBits::eFragmentShadingRateAttachmentKHR : return "FragmentShadingRateAttachmentKHR";
2252       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2253     }
2254 
2255   }
2256 
2257 
to_string(MemoryMapFlagBits)2258   VULKAN_HPP_INLINE std::string to_string( MemoryMapFlagBits )
2259   {
2260     return "(void)";
2261   }
2262 
2263 
to_string(ImageAspectFlagBits value)2264   VULKAN_HPP_INLINE std::string to_string( ImageAspectFlagBits value )
2265   {
2266     switch ( value )
2267     {
2268       case ImageAspectFlagBits::eColor : return "Color";
2269       case ImageAspectFlagBits::eDepth : return "Depth";
2270       case ImageAspectFlagBits::eStencil : return "Stencil";
2271       case ImageAspectFlagBits::eMetadata : return "Metadata";
2272       case ImageAspectFlagBits::ePlane0 : return "Plane0";
2273       case ImageAspectFlagBits::ePlane1 : return "Plane1";
2274       case ImageAspectFlagBits::ePlane2 : return "Plane2";
2275       case ImageAspectFlagBits::eNone : return "None";
2276       case ImageAspectFlagBits::eMemoryPlane0EXT : return "MemoryPlane0EXT";
2277       case ImageAspectFlagBits::eMemoryPlane1EXT : return "MemoryPlane1EXT";
2278       case ImageAspectFlagBits::eMemoryPlane2EXT : return "MemoryPlane2EXT";
2279       case ImageAspectFlagBits::eMemoryPlane3EXT : return "MemoryPlane3EXT";
2280       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2281     }
2282 
2283   }
2284 
2285 
to_string(FenceCreateFlagBits value)2286   VULKAN_HPP_INLINE std::string to_string( FenceCreateFlagBits value )
2287   {
2288     switch ( value )
2289     {
2290       case FenceCreateFlagBits::eSignaled : return "Signaled";
2291       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2292     }
2293 
2294   }
2295 
2296 
to_string(SemaphoreCreateFlagBits)2297   VULKAN_HPP_INLINE std::string to_string( SemaphoreCreateFlagBits )
2298   {
2299     return "(void)";
2300   }
2301 
2302 
to_string(EventCreateFlagBits value)2303   VULKAN_HPP_INLINE std::string to_string( EventCreateFlagBits value )
2304   {
2305     switch ( value )
2306     {
2307       case EventCreateFlagBits::eDeviceOnly : return "DeviceOnly";
2308       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2309     }
2310 
2311   }
2312 
2313 
to_string(QueryPipelineStatisticFlagBits value)2314   VULKAN_HPP_INLINE std::string to_string( QueryPipelineStatisticFlagBits value )
2315   {
2316     switch ( value )
2317     {
2318       case QueryPipelineStatisticFlagBits::eInputAssemblyVertices : return "InputAssemblyVertices";
2319       case QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives : return "InputAssemblyPrimitives";
2320       case QueryPipelineStatisticFlagBits::eVertexShaderInvocations : return "VertexShaderInvocations";
2321       case QueryPipelineStatisticFlagBits::eGeometryShaderInvocations : return "GeometryShaderInvocations";
2322       case QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives : return "GeometryShaderPrimitives";
2323       case QueryPipelineStatisticFlagBits::eClippingInvocations : return "ClippingInvocations";
2324       case QueryPipelineStatisticFlagBits::eClippingPrimitives : return "ClippingPrimitives";
2325       case QueryPipelineStatisticFlagBits::eFragmentShaderInvocations : return "FragmentShaderInvocations";
2326       case QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches : return "TessellationControlShaderPatches";
2327       case QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations : return "TessellationEvaluationShaderInvocations";
2328       case QueryPipelineStatisticFlagBits::eComputeShaderInvocations : return "ComputeShaderInvocations";
2329       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2330     }
2331 
2332   }
2333 
2334 
to_string(QueryResultFlagBits value)2335   VULKAN_HPP_INLINE std::string to_string( QueryResultFlagBits value )
2336   {
2337     switch ( value )
2338     {
2339       case QueryResultFlagBits::e64 : return "64";
2340       case QueryResultFlagBits::eWait : return "Wait";
2341       case QueryResultFlagBits::eWithAvailability : return "WithAvailability";
2342       case QueryResultFlagBits::ePartial : return "Partial";
2343       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2344     }
2345 
2346   }
2347 
2348 
to_string(QueryType value)2349   VULKAN_HPP_INLINE std::string to_string( QueryType value )
2350   {
2351     switch ( value )
2352     {
2353       case QueryType::eOcclusion : return "Occlusion";
2354       case QueryType::ePipelineStatistics : return "PipelineStatistics";
2355       case QueryType::eTimestamp : return "Timestamp";
2356       case QueryType::ePerformanceQueryKHR : return "PerformanceQueryKHR";
2357       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2358     }
2359 
2360   }
2361 
2362 
to_string(QueryPoolCreateFlagBits)2363   VULKAN_HPP_INLINE std::string to_string( QueryPoolCreateFlagBits )
2364   {
2365     return "(void)";
2366   }
2367 
2368 
to_string(BufferCreateFlagBits value)2369   VULKAN_HPP_INLINE std::string to_string( BufferCreateFlagBits value )
2370   {
2371     switch ( value )
2372     {
2373       case BufferCreateFlagBits::eSparseBinding : return "SparseBinding";
2374       case BufferCreateFlagBits::eSparseResidency : return "SparseResidency";
2375       case BufferCreateFlagBits::eSparseAliased : return "SparseAliased";
2376       case BufferCreateFlagBits::eProtected : return "Protected";
2377       case BufferCreateFlagBits::eDeviceAddressCaptureReplay : return "DeviceAddressCaptureReplay";
2378       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2379     }
2380 
2381   }
2382 
2383 
to_string(BufferUsageFlagBits value)2384   VULKAN_HPP_INLINE std::string to_string( BufferUsageFlagBits value )
2385   {
2386     switch ( value )
2387     {
2388       case BufferUsageFlagBits::eTransferSrc : return "TransferSrc";
2389       case BufferUsageFlagBits::eTransferDst : return "TransferDst";
2390       case BufferUsageFlagBits::eUniformTexelBuffer : return "UniformTexelBuffer";
2391       case BufferUsageFlagBits::eStorageTexelBuffer : return "StorageTexelBuffer";
2392       case BufferUsageFlagBits::eUniformBuffer : return "UniformBuffer";
2393       case BufferUsageFlagBits::eStorageBuffer : return "StorageBuffer";
2394       case BufferUsageFlagBits::eIndexBuffer : return "IndexBuffer";
2395       case BufferUsageFlagBits::eVertexBuffer : return "VertexBuffer";
2396       case BufferUsageFlagBits::eIndirectBuffer : return "IndirectBuffer";
2397       case BufferUsageFlagBits::eShaderDeviceAddress : return "ShaderDeviceAddress";
2398       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2399     }
2400 
2401   }
2402 
2403 
to_string(SharingMode value)2404   VULKAN_HPP_INLINE std::string to_string( SharingMode value )
2405   {
2406     switch ( value )
2407     {
2408       case SharingMode::eExclusive : return "Exclusive";
2409       case SharingMode::eConcurrent : return "Concurrent";
2410       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2411     }
2412 
2413   }
2414 
2415 
to_string(BufferViewCreateFlagBits)2416   VULKAN_HPP_INLINE std::string to_string( BufferViewCreateFlagBits )
2417   {
2418     return "(void)";
2419   }
2420 
2421 
to_string(ImageLayout value)2422   VULKAN_HPP_INLINE std::string to_string( ImageLayout value )
2423   {
2424     switch ( value )
2425     {
2426       case ImageLayout::eUndefined : return "Undefined";
2427       case ImageLayout::eGeneral : return "General";
2428       case ImageLayout::eColorAttachmentOptimal : return "ColorAttachmentOptimal";
2429       case ImageLayout::eDepthStencilAttachmentOptimal : return "DepthStencilAttachmentOptimal";
2430       case ImageLayout::eDepthStencilReadOnlyOptimal : return "DepthStencilReadOnlyOptimal";
2431       case ImageLayout::eShaderReadOnlyOptimal : return "ShaderReadOnlyOptimal";
2432       case ImageLayout::eTransferSrcOptimal : return "TransferSrcOptimal";
2433       case ImageLayout::eTransferDstOptimal : return "TransferDstOptimal";
2434       case ImageLayout::ePreinitialized : return "Preinitialized";
2435       case ImageLayout::eDepthReadOnlyStencilAttachmentOptimal : return "DepthReadOnlyStencilAttachmentOptimal";
2436       case ImageLayout::eDepthAttachmentStencilReadOnlyOptimal : return "DepthAttachmentStencilReadOnlyOptimal";
2437       case ImageLayout::eDepthAttachmentOptimal : return "DepthAttachmentOptimal";
2438       case ImageLayout::eDepthReadOnlyOptimal : return "DepthReadOnlyOptimal";
2439       case ImageLayout::eStencilAttachmentOptimal : return "StencilAttachmentOptimal";
2440       case ImageLayout::eStencilReadOnlyOptimal : return "StencilReadOnlyOptimal";
2441       case ImageLayout::eReadOnlyOptimal : return "ReadOnlyOptimal";
2442       case ImageLayout::eAttachmentOptimal : return "AttachmentOptimal";
2443       case ImageLayout::ePresentSrcKHR : return "PresentSrcKHR";
2444       case ImageLayout::eSharedPresentKHR : return "SharedPresentKHR";
2445       case ImageLayout::eFragmentShadingRateAttachmentOptimalKHR : return "FragmentShadingRateAttachmentOptimalKHR";
2446       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2447     }
2448 
2449   }
2450 
2451 
to_string(ComponentSwizzle value)2452   VULKAN_HPP_INLINE std::string to_string( ComponentSwizzle value )
2453   {
2454     switch ( value )
2455     {
2456       case ComponentSwizzle::eIdentity : return "Identity";
2457       case ComponentSwizzle::eZero : return "Zero";
2458       case ComponentSwizzle::eOne : return "One";
2459       case ComponentSwizzle::eR : return "R";
2460       case ComponentSwizzle::eG : return "G";
2461       case ComponentSwizzle::eB : return "B";
2462       case ComponentSwizzle::eA : return "A";
2463       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2464     }
2465 
2466   }
2467 
2468 
to_string(ImageViewCreateFlagBits)2469   VULKAN_HPP_INLINE std::string to_string( ImageViewCreateFlagBits )
2470   {
2471     return "(void)";
2472   }
2473 
2474 
to_string(ImageViewType value)2475   VULKAN_HPP_INLINE std::string to_string( ImageViewType value )
2476   {
2477     switch ( value )
2478     {
2479       case ImageViewType::e1D : return "1D";
2480       case ImageViewType::e2D : return "2D";
2481       case ImageViewType::e3D : return "3D";
2482       case ImageViewType::eCube : return "Cube";
2483       case ImageViewType::e1DArray : return "1DArray";
2484       case ImageViewType::e2DArray : return "2DArray";
2485       case ImageViewType::eCubeArray : return "CubeArray";
2486       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2487     }
2488 
2489   }
2490 
2491 
to_string(PipelineCacheCreateFlagBits value)2492   VULKAN_HPP_INLINE std::string to_string( PipelineCacheCreateFlagBits value )
2493   {
2494     switch ( value )
2495     {
2496       case PipelineCacheCreateFlagBits::eExternallySynchronized : return "ExternallySynchronized";
2497       case PipelineCacheCreateFlagBits::eReadOnly : return "ReadOnly";
2498       case PipelineCacheCreateFlagBits::eUseApplicationStorage : return "UseApplicationStorage";
2499       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2500     }
2501 
2502   }
2503 
2504 
to_string(BlendFactor value)2505   VULKAN_HPP_INLINE std::string to_string( BlendFactor value )
2506   {
2507     switch ( value )
2508     {
2509       case BlendFactor::eZero : return "Zero";
2510       case BlendFactor::eOne : return "One";
2511       case BlendFactor::eSrcColor : return "SrcColor";
2512       case BlendFactor::eOneMinusSrcColor : return "OneMinusSrcColor";
2513       case BlendFactor::eDstColor : return "DstColor";
2514       case BlendFactor::eOneMinusDstColor : return "OneMinusDstColor";
2515       case BlendFactor::eSrcAlpha : return "SrcAlpha";
2516       case BlendFactor::eOneMinusSrcAlpha : return "OneMinusSrcAlpha";
2517       case BlendFactor::eDstAlpha : return "DstAlpha";
2518       case BlendFactor::eOneMinusDstAlpha : return "OneMinusDstAlpha";
2519       case BlendFactor::eConstantColor : return "ConstantColor";
2520       case BlendFactor::eOneMinusConstantColor : return "OneMinusConstantColor";
2521       case BlendFactor::eConstantAlpha : return "ConstantAlpha";
2522       case BlendFactor::eOneMinusConstantAlpha : return "OneMinusConstantAlpha";
2523       case BlendFactor::eSrcAlphaSaturate : return "SrcAlphaSaturate";
2524       case BlendFactor::eSrc1Color : return "Src1Color";
2525       case BlendFactor::eOneMinusSrc1Color : return "OneMinusSrc1Color";
2526       case BlendFactor::eSrc1Alpha : return "Src1Alpha";
2527       case BlendFactor::eOneMinusSrc1Alpha : return "OneMinusSrc1Alpha";
2528       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2529     }
2530 
2531   }
2532 
2533 
to_string(BlendOp value)2534   VULKAN_HPP_INLINE std::string to_string( BlendOp value )
2535   {
2536     switch ( value )
2537     {
2538       case BlendOp::eAdd : return "Add";
2539       case BlendOp::eSubtract : return "Subtract";
2540       case BlendOp::eReverseSubtract : return "ReverseSubtract";
2541       case BlendOp::eMin : return "Min";
2542       case BlendOp::eMax : return "Max";
2543       case BlendOp::eZeroEXT : return "ZeroEXT";
2544       case BlendOp::eSrcEXT : return "SrcEXT";
2545       case BlendOp::eDstEXT : return "DstEXT";
2546       case BlendOp::eSrcOverEXT : return "SrcOverEXT";
2547       case BlendOp::eDstOverEXT : return "DstOverEXT";
2548       case BlendOp::eSrcInEXT : return "SrcInEXT";
2549       case BlendOp::eDstInEXT : return "DstInEXT";
2550       case BlendOp::eSrcOutEXT : return "SrcOutEXT";
2551       case BlendOp::eDstOutEXT : return "DstOutEXT";
2552       case BlendOp::eSrcAtopEXT : return "SrcAtopEXT";
2553       case BlendOp::eDstAtopEXT : return "DstAtopEXT";
2554       case BlendOp::eXorEXT : return "XorEXT";
2555       case BlendOp::eMultiplyEXT : return "MultiplyEXT";
2556       case BlendOp::eScreenEXT : return "ScreenEXT";
2557       case BlendOp::eOverlayEXT : return "OverlayEXT";
2558       case BlendOp::eDarkenEXT : return "DarkenEXT";
2559       case BlendOp::eLightenEXT : return "LightenEXT";
2560       case BlendOp::eColordodgeEXT : return "ColordodgeEXT";
2561       case BlendOp::eColorburnEXT : return "ColorburnEXT";
2562       case BlendOp::eHardlightEXT : return "HardlightEXT";
2563       case BlendOp::eSoftlightEXT : return "SoftlightEXT";
2564       case BlendOp::eDifferenceEXT : return "DifferenceEXT";
2565       case BlendOp::eExclusionEXT : return "ExclusionEXT";
2566       case BlendOp::eInvertEXT : return "InvertEXT";
2567       case BlendOp::eInvertRgbEXT : return "InvertRgbEXT";
2568       case BlendOp::eLineardodgeEXT : return "LineardodgeEXT";
2569       case BlendOp::eLinearburnEXT : return "LinearburnEXT";
2570       case BlendOp::eVividlightEXT : return "VividlightEXT";
2571       case BlendOp::eLinearlightEXT : return "LinearlightEXT";
2572       case BlendOp::ePinlightEXT : return "PinlightEXT";
2573       case BlendOp::eHardmixEXT : return "HardmixEXT";
2574       case BlendOp::eHslHueEXT : return "HslHueEXT";
2575       case BlendOp::eHslSaturationEXT : return "HslSaturationEXT";
2576       case BlendOp::eHslColorEXT : return "HslColorEXT";
2577       case BlendOp::eHslLuminosityEXT : return "HslLuminosityEXT";
2578       case BlendOp::ePlusEXT : return "PlusEXT";
2579       case BlendOp::ePlusClampedEXT : return "PlusClampedEXT";
2580       case BlendOp::ePlusClampedAlphaEXT : return "PlusClampedAlphaEXT";
2581       case BlendOp::ePlusDarkerEXT : return "PlusDarkerEXT";
2582       case BlendOp::eMinusEXT : return "MinusEXT";
2583       case BlendOp::eMinusClampedEXT : return "MinusClampedEXT";
2584       case BlendOp::eContrastEXT : return "ContrastEXT";
2585       case BlendOp::eInvertOvgEXT : return "InvertOvgEXT";
2586       case BlendOp::eRedEXT : return "RedEXT";
2587       case BlendOp::eGreenEXT : return "GreenEXT";
2588       case BlendOp::eBlueEXT : return "BlueEXT";
2589       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2590     }
2591 
2592   }
2593 
2594 
to_string(ColorComponentFlagBits value)2595   VULKAN_HPP_INLINE std::string to_string( ColorComponentFlagBits value )
2596   {
2597     switch ( value )
2598     {
2599       case ColorComponentFlagBits::eR : return "R";
2600       case ColorComponentFlagBits::eG : return "G";
2601       case ColorComponentFlagBits::eB : return "B";
2602       case ColorComponentFlagBits::eA : return "A";
2603       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2604     }
2605 
2606   }
2607 
2608 
to_string(CompareOp value)2609   VULKAN_HPP_INLINE std::string to_string( CompareOp value )
2610   {
2611     switch ( value )
2612     {
2613       case CompareOp::eNever : return "Never";
2614       case CompareOp::eLess : return "Less";
2615       case CompareOp::eEqual : return "Equal";
2616       case CompareOp::eLessOrEqual : return "LessOrEqual";
2617       case CompareOp::eGreater : return "Greater";
2618       case CompareOp::eNotEqual : return "NotEqual";
2619       case CompareOp::eGreaterOrEqual : return "GreaterOrEqual";
2620       case CompareOp::eAlways : return "Always";
2621       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2622     }
2623 
2624   }
2625 
2626 
to_string(CullModeFlagBits value)2627   VULKAN_HPP_INLINE std::string to_string( CullModeFlagBits value )
2628   {
2629     switch ( value )
2630     {
2631       case CullModeFlagBits::eNone : return "None";
2632       case CullModeFlagBits::eFront : return "Front";
2633       case CullModeFlagBits::eBack : return "Back";
2634       case CullModeFlagBits::eFrontAndBack : return "FrontAndBack";
2635       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2636     }
2637 
2638   }
2639 
2640 
to_string(DynamicState value)2641   VULKAN_HPP_INLINE std::string to_string( DynamicState value )
2642   {
2643     switch ( value )
2644     {
2645       case DynamicState::eViewport : return "Viewport";
2646       case DynamicState::eScissor : return "Scissor";
2647       case DynamicState::eLineWidth : return "LineWidth";
2648       case DynamicState::eDepthBias : return "DepthBias";
2649       case DynamicState::eBlendConstants : return "BlendConstants";
2650       case DynamicState::eDepthBounds : return "DepthBounds";
2651       case DynamicState::eStencilCompareMask : return "StencilCompareMask";
2652       case DynamicState::eStencilWriteMask : return "StencilWriteMask";
2653       case DynamicState::eStencilReference : return "StencilReference";
2654       case DynamicState::eCullMode : return "CullMode";
2655       case DynamicState::eFrontFace : return "FrontFace";
2656       case DynamicState::ePrimitiveTopology : return "PrimitiveTopology";
2657       case DynamicState::eViewportWithCount : return "ViewportWithCount";
2658       case DynamicState::eScissorWithCount : return "ScissorWithCount";
2659       case DynamicState::eVertexInputBindingStride : return "VertexInputBindingStride";
2660       case DynamicState::eDepthTestEnable : return "DepthTestEnable";
2661       case DynamicState::eDepthWriteEnable : return "DepthWriteEnable";
2662       case DynamicState::eDepthCompareOp : return "DepthCompareOp";
2663       case DynamicState::eDepthBoundsTestEnable : return "DepthBoundsTestEnable";
2664       case DynamicState::eStencilTestEnable : return "StencilTestEnable";
2665       case DynamicState::eStencilOp : return "StencilOp";
2666       case DynamicState::eRasterizerDiscardEnable : return "RasterizerDiscardEnable";
2667       case DynamicState::eDepthBiasEnable : return "DepthBiasEnable";
2668       case DynamicState::ePrimitiveRestartEnable : return "PrimitiveRestartEnable";
2669       case DynamicState::eDiscardRectangleEXT : return "DiscardRectangleEXT";
2670       case DynamicState::eDiscardRectangleEnableEXT : return "DiscardRectangleEnableEXT";
2671       case DynamicState::eDiscardRectangleModeEXT : return "DiscardRectangleModeEXT";
2672       case DynamicState::eSampleLocationsEXT : return "SampleLocationsEXT";
2673       case DynamicState::eFragmentShadingRateKHR : return "FragmentShadingRateKHR";
2674       case DynamicState::eLineStippleEXT : return "LineStippleEXT";
2675       case DynamicState::eVertexInputEXT : return "VertexInputEXT";
2676       case DynamicState::ePatchControlPointsEXT : return "PatchControlPointsEXT";
2677       case DynamicState::eLogicOpEXT : return "LogicOpEXT";
2678       case DynamicState::eColorWriteEnableEXT : return "ColorWriteEnableEXT";
2679       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2680     }
2681 
2682   }
2683 
2684 
to_string(FrontFace value)2685   VULKAN_HPP_INLINE std::string to_string( FrontFace value )
2686   {
2687     switch ( value )
2688     {
2689       case FrontFace::eCounterClockwise : return "CounterClockwise";
2690       case FrontFace::eClockwise : return "Clockwise";
2691       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2692     }
2693 
2694   }
2695 
2696 
to_string(LogicOp value)2697   VULKAN_HPP_INLINE std::string to_string( LogicOp value )
2698   {
2699     switch ( value )
2700     {
2701       case LogicOp::eClear : return "Clear";
2702       case LogicOp::eAnd : return "And";
2703       case LogicOp::eAndReverse : return "AndReverse";
2704       case LogicOp::eCopy : return "Copy";
2705       case LogicOp::eAndInverted : return "AndInverted";
2706       case LogicOp::eNoOp : return "NoOp";
2707       case LogicOp::eXor : return "Xor";
2708       case LogicOp::eOr : return "Or";
2709       case LogicOp::eNor : return "Nor";
2710       case LogicOp::eEquivalent : return "Equivalent";
2711       case LogicOp::eInvert : return "Invert";
2712       case LogicOp::eOrReverse : return "OrReverse";
2713       case LogicOp::eCopyInverted : return "CopyInverted";
2714       case LogicOp::eOrInverted : return "OrInverted";
2715       case LogicOp::eNand : return "Nand";
2716       case LogicOp::eSet : return "Set";
2717       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2718     }
2719 
2720   }
2721 
2722 
to_string(PipelineCreateFlagBits value)2723   VULKAN_HPP_INLINE std::string to_string( PipelineCreateFlagBits value )
2724   {
2725     switch ( value )
2726     {
2727       case PipelineCreateFlagBits::eDisableOptimization : return "DisableOptimization";
2728       case PipelineCreateFlagBits::eViewIndexFromDeviceIndex : return "ViewIndexFromDeviceIndex";
2729       case PipelineCreateFlagBits::eDispatchBase : return "DispatchBase";
2730       case PipelineCreateFlagBits::eFailOnPipelineCompileRequired : return "FailOnPipelineCompileRequired";
2731       case PipelineCreateFlagBits::eEarlyReturnOnFailure : return "EarlyReturnOnFailure";
2732       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2733     }
2734 
2735   }
2736 
2737 
to_string(PipelineShaderStageCreateFlagBits value)2738   VULKAN_HPP_INLINE std::string to_string( PipelineShaderStageCreateFlagBits value )
2739   {
2740     switch ( value )
2741     {
2742       case PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSize : return "AllowVaryingSubgroupSize";
2743       case PipelineShaderStageCreateFlagBits::eRequireFullSubgroups : return "RequireFullSubgroups";
2744       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2745     }
2746 
2747   }
2748 
2749 
to_string(PolygonMode value)2750   VULKAN_HPP_INLINE std::string to_string( PolygonMode value )
2751   {
2752     switch ( value )
2753     {
2754       case PolygonMode::eFill : return "Fill";
2755       case PolygonMode::eLine : return "Line";
2756       case PolygonMode::ePoint : return "Point";
2757       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2758     }
2759 
2760   }
2761 
2762 
to_string(PrimitiveTopology value)2763   VULKAN_HPP_INLINE std::string to_string( PrimitiveTopology value )
2764   {
2765     switch ( value )
2766     {
2767       case PrimitiveTopology::ePointList : return "PointList";
2768       case PrimitiveTopology::eLineList : return "LineList";
2769       case PrimitiveTopology::eLineStrip : return "LineStrip";
2770       case PrimitiveTopology::eTriangleList : return "TriangleList";
2771       case PrimitiveTopology::eTriangleStrip : return "TriangleStrip";
2772       case PrimitiveTopology::eTriangleFan : return "TriangleFan";
2773       case PrimitiveTopology::eLineListWithAdjacency : return "LineListWithAdjacency";
2774       case PrimitiveTopology::eLineStripWithAdjacency : return "LineStripWithAdjacency";
2775       case PrimitiveTopology::eTriangleListWithAdjacency : return "TriangleListWithAdjacency";
2776       case PrimitiveTopology::eTriangleStripWithAdjacency : return "TriangleStripWithAdjacency";
2777       case PrimitiveTopology::ePatchList : return "PatchList";
2778       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2779     }
2780 
2781   }
2782 
2783 
to_string(ShaderStageFlagBits value)2784   VULKAN_HPP_INLINE std::string to_string( ShaderStageFlagBits value )
2785   {
2786     switch ( value )
2787     {
2788       case ShaderStageFlagBits::eVertex : return "Vertex";
2789       case ShaderStageFlagBits::eTessellationControl : return "TessellationControl";
2790       case ShaderStageFlagBits::eTessellationEvaluation : return "TessellationEvaluation";
2791       case ShaderStageFlagBits::eGeometry : return "Geometry";
2792       case ShaderStageFlagBits::eFragment : return "Fragment";
2793       case ShaderStageFlagBits::eCompute : return "Compute";
2794       case ShaderStageFlagBits::eAllGraphics : return "AllGraphics";
2795       case ShaderStageFlagBits::eAll : return "All";
2796       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2797     }
2798 
2799   }
2800 
2801 
to_string(StencilOp value)2802   VULKAN_HPP_INLINE std::string to_string( StencilOp value )
2803   {
2804     switch ( value )
2805     {
2806       case StencilOp::eKeep : return "Keep";
2807       case StencilOp::eZero : return "Zero";
2808       case StencilOp::eReplace : return "Replace";
2809       case StencilOp::eIncrementAndClamp : return "IncrementAndClamp";
2810       case StencilOp::eDecrementAndClamp : return "DecrementAndClamp";
2811       case StencilOp::eInvert : return "Invert";
2812       case StencilOp::eIncrementAndWrap : return "IncrementAndWrap";
2813       case StencilOp::eDecrementAndWrap : return "DecrementAndWrap";
2814       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2815     }
2816 
2817   }
2818 
2819 
to_string(VertexInputRate value)2820   VULKAN_HPP_INLINE std::string to_string( VertexInputRate value )
2821   {
2822     switch ( value )
2823     {
2824       case VertexInputRate::eVertex : return "Vertex";
2825       case VertexInputRate::eInstance : return "Instance";
2826       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2827     }
2828 
2829   }
2830 
2831 
to_string(PipelineColorBlendStateCreateFlagBits)2832   VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlagBits )
2833   {
2834     return "(void)";
2835   }
2836 
2837 
to_string(PipelineDepthStencilStateCreateFlagBits)2838   VULKAN_HPP_INLINE std::string to_string( PipelineDepthStencilStateCreateFlagBits )
2839   {
2840     return "(void)";
2841   }
2842 
2843 
to_string(PipelineDynamicStateCreateFlagBits)2844   VULKAN_HPP_INLINE std::string to_string( PipelineDynamicStateCreateFlagBits )
2845   {
2846     return "(void)";
2847   }
2848 
2849 
to_string(PipelineInputAssemblyStateCreateFlagBits)2850   VULKAN_HPP_INLINE std::string to_string( PipelineInputAssemblyStateCreateFlagBits )
2851   {
2852     return "(void)";
2853   }
2854 
2855 
to_string(PipelineLayoutCreateFlagBits)2856   VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlagBits )
2857   {
2858     return "(void)";
2859   }
2860 
2861 
to_string(PipelineMultisampleStateCreateFlagBits)2862   VULKAN_HPP_INLINE std::string to_string( PipelineMultisampleStateCreateFlagBits )
2863   {
2864     return "(void)";
2865   }
2866 
2867 
to_string(PipelineRasterizationStateCreateFlagBits)2868   VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateCreateFlagBits )
2869   {
2870     return "(void)";
2871   }
2872 
2873 
to_string(PipelineTessellationStateCreateFlagBits)2874   VULKAN_HPP_INLINE std::string to_string( PipelineTessellationStateCreateFlagBits )
2875   {
2876     return "(void)";
2877   }
2878 
2879 
to_string(PipelineVertexInputStateCreateFlagBits)2880   VULKAN_HPP_INLINE std::string to_string( PipelineVertexInputStateCreateFlagBits )
2881   {
2882     return "(void)";
2883   }
2884 
2885 
to_string(PipelineViewportStateCreateFlagBits)2886   VULKAN_HPP_INLINE std::string to_string( PipelineViewportStateCreateFlagBits )
2887   {
2888     return "(void)";
2889   }
2890 
2891 
to_string(BorderColor value)2892   VULKAN_HPP_INLINE std::string to_string( BorderColor value )
2893   {
2894     switch ( value )
2895     {
2896       case BorderColor::eFloatTransparentBlack : return "FloatTransparentBlack";
2897       case BorderColor::eIntTransparentBlack : return "IntTransparentBlack";
2898       case BorderColor::eFloatOpaqueBlack : return "FloatOpaqueBlack";
2899       case BorderColor::eIntOpaqueBlack : return "IntOpaqueBlack";
2900       case BorderColor::eFloatOpaqueWhite : return "FloatOpaqueWhite";
2901       case BorderColor::eIntOpaqueWhite : return "IntOpaqueWhite";
2902       case BorderColor::eFloatCustomEXT : return "FloatCustomEXT";
2903       case BorderColor::eIntCustomEXT : return "IntCustomEXT";
2904       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2905     }
2906 
2907   }
2908 
2909 
to_string(Filter value)2910   VULKAN_HPP_INLINE std::string to_string( Filter value )
2911   {
2912     switch ( value )
2913     {
2914       case Filter::eNearest : return "Nearest";
2915       case Filter::eLinear : return "Linear";
2916       case Filter::eCubicEXT : return "CubicEXT";
2917       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2918     }
2919 
2920   }
2921 
2922 
to_string(SamplerAddressMode value)2923   VULKAN_HPP_INLINE std::string to_string( SamplerAddressMode value )
2924   {
2925     switch ( value )
2926     {
2927       case SamplerAddressMode::eRepeat : return "Repeat";
2928       case SamplerAddressMode::eMirroredRepeat : return "MirroredRepeat";
2929       case SamplerAddressMode::eClampToEdge : return "ClampToEdge";
2930       case SamplerAddressMode::eClampToBorder : return "ClampToBorder";
2931       case SamplerAddressMode::eMirrorClampToEdge : return "MirrorClampToEdge";
2932       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2933     }
2934 
2935   }
2936 
2937 
to_string(SamplerCreateFlagBits)2938   VULKAN_HPP_INLINE std::string to_string( SamplerCreateFlagBits )
2939   {
2940     return "(void)";
2941   }
2942 
2943 
to_string(SamplerMipmapMode value)2944   VULKAN_HPP_INLINE std::string to_string( SamplerMipmapMode value )
2945   {
2946     switch ( value )
2947     {
2948       case SamplerMipmapMode::eNearest : return "Nearest";
2949       case SamplerMipmapMode::eLinear : return "Linear";
2950       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2951     }
2952 
2953   }
2954 
2955 
to_string(DescriptorPoolCreateFlagBits value)2956   VULKAN_HPP_INLINE std::string to_string( DescriptorPoolCreateFlagBits value )
2957   {
2958     switch ( value )
2959     {
2960       case DescriptorPoolCreateFlagBits::eFreeDescriptorSet : return "FreeDescriptorSet";
2961       case DescriptorPoolCreateFlagBits::eUpdateAfterBind : return "UpdateAfterBind";
2962       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2963     }
2964 
2965   }
2966 
2967 
to_string(DescriptorSetLayoutCreateFlagBits value)2968   VULKAN_HPP_INLINE std::string to_string( DescriptorSetLayoutCreateFlagBits value )
2969   {
2970     switch ( value )
2971     {
2972       case DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool : return "UpdateAfterBindPool";
2973       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2974     }
2975 
2976   }
2977 
2978 
to_string(DescriptorType value)2979   VULKAN_HPP_INLINE std::string to_string( DescriptorType value )
2980   {
2981     switch ( value )
2982     {
2983       case DescriptorType::eSampler : return "Sampler";
2984       case DescriptorType::eCombinedImageSampler : return "CombinedImageSampler";
2985       case DescriptorType::eSampledImage : return "SampledImage";
2986       case DescriptorType::eStorageImage : return "StorageImage";
2987       case DescriptorType::eUniformTexelBuffer : return "UniformTexelBuffer";
2988       case DescriptorType::eStorageTexelBuffer : return "StorageTexelBuffer";
2989       case DescriptorType::eUniformBuffer : return "UniformBuffer";
2990       case DescriptorType::eStorageBuffer : return "StorageBuffer";
2991       case DescriptorType::eUniformBufferDynamic : return "UniformBufferDynamic";
2992       case DescriptorType::eStorageBufferDynamic : return "StorageBufferDynamic";
2993       case DescriptorType::eInputAttachment : return "InputAttachment";
2994       case DescriptorType::eInlineUniformBlock : return "InlineUniformBlock";
2995       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
2996     }
2997 
2998   }
2999 
3000 
to_string(DescriptorPoolResetFlagBits)3001   VULKAN_HPP_INLINE std::string to_string( DescriptorPoolResetFlagBits )
3002   {
3003     return "(void)";
3004   }
3005 
3006 
to_string(AccessFlagBits value)3007   VULKAN_HPP_INLINE std::string to_string( AccessFlagBits value )
3008   {
3009     switch ( value )
3010     {
3011       case AccessFlagBits::eIndirectCommandRead : return "IndirectCommandRead";
3012       case AccessFlagBits::eIndexRead : return "IndexRead";
3013       case AccessFlagBits::eVertexAttributeRead : return "VertexAttributeRead";
3014       case AccessFlagBits::eUniformRead : return "UniformRead";
3015       case AccessFlagBits::eInputAttachmentRead : return "InputAttachmentRead";
3016       case AccessFlagBits::eShaderRead : return "ShaderRead";
3017       case AccessFlagBits::eShaderWrite : return "ShaderWrite";
3018       case AccessFlagBits::eColorAttachmentRead : return "ColorAttachmentRead";
3019       case AccessFlagBits::eColorAttachmentWrite : return "ColorAttachmentWrite";
3020       case AccessFlagBits::eDepthStencilAttachmentRead : return "DepthStencilAttachmentRead";
3021       case AccessFlagBits::eDepthStencilAttachmentWrite : return "DepthStencilAttachmentWrite";
3022       case AccessFlagBits::eTransferRead : return "TransferRead";
3023       case AccessFlagBits::eTransferWrite : return "TransferWrite";
3024       case AccessFlagBits::eHostRead : return "HostRead";
3025       case AccessFlagBits::eHostWrite : return "HostWrite";
3026       case AccessFlagBits::eMemoryRead : return "MemoryRead";
3027       case AccessFlagBits::eMemoryWrite : return "MemoryWrite";
3028       case AccessFlagBits::eNone : return "None";
3029       case AccessFlagBits::eColorAttachmentReadNoncoherentEXT : return "ColorAttachmentReadNoncoherentEXT";
3030       case AccessFlagBits::eFragmentShadingRateAttachmentReadKHR : return "FragmentShadingRateAttachmentReadKHR";
3031       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3032     }
3033 
3034   }
3035 
3036 
to_string(AttachmentDescriptionFlagBits value)3037   VULKAN_HPP_INLINE std::string to_string( AttachmentDescriptionFlagBits value )
3038   {
3039     switch ( value )
3040     {
3041       case AttachmentDescriptionFlagBits::eMayAlias : return "MayAlias";
3042       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3043     }
3044 
3045   }
3046 
3047 
to_string(AttachmentLoadOp value)3048   VULKAN_HPP_INLINE std::string to_string( AttachmentLoadOp value )
3049   {
3050     switch ( value )
3051     {
3052       case AttachmentLoadOp::eLoad : return "Load";
3053       case AttachmentLoadOp::eClear : return "Clear";
3054       case AttachmentLoadOp::eDontCare : return "DontCare";
3055       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3056     }
3057 
3058   }
3059 
3060 
to_string(AttachmentStoreOp value)3061   VULKAN_HPP_INLINE std::string to_string( AttachmentStoreOp value )
3062   {
3063     switch ( value )
3064     {
3065       case AttachmentStoreOp::eStore : return "Store";
3066       case AttachmentStoreOp::eDontCare : return "DontCare";
3067       case AttachmentStoreOp::eNone : return "None";
3068       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3069     }
3070 
3071   }
3072 
3073 
to_string(DependencyFlagBits value)3074   VULKAN_HPP_INLINE std::string to_string( DependencyFlagBits value )
3075   {
3076     switch ( value )
3077     {
3078       case DependencyFlagBits::eByRegion : return "ByRegion";
3079       case DependencyFlagBits::eDeviceGroup : return "DeviceGroup";
3080       case DependencyFlagBits::eViewLocal : return "ViewLocal";
3081       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3082     }
3083 
3084   }
3085 
3086 
to_string(FramebufferCreateFlagBits value)3087   VULKAN_HPP_INLINE std::string to_string( FramebufferCreateFlagBits value )
3088   {
3089     switch ( value )
3090     {
3091       case FramebufferCreateFlagBits::eImageless : return "Imageless";
3092       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3093     }
3094 
3095   }
3096 
3097 
to_string(PipelineBindPoint value)3098   VULKAN_HPP_INLINE std::string to_string( PipelineBindPoint value )
3099   {
3100     switch ( value )
3101     {
3102       case PipelineBindPoint::eGraphics : return "Graphics";
3103       case PipelineBindPoint::eCompute : return "Compute";
3104       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3105     }
3106 
3107   }
3108 
3109 
to_string(RenderPassCreateFlagBits)3110   VULKAN_HPP_INLINE std::string to_string( RenderPassCreateFlagBits )
3111   {
3112     return "(void)";
3113   }
3114 
3115 
to_string(SubpassDescriptionFlagBits)3116   VULKAN_HPP_INLINE std::string to_string( SubpassDescriptionFlagBits )
3117   {
3118     return "(void)";
3119   }
3120 
3121 
to_string(CommandPoolCreateFlagBits value)3122   VULKAN_HPP_INLINE std::string to_string( CommandPoolCreateFlagBits value )
3123   {
3124     switch ( value )
3125     {
3126       case CommandPoolCreateFlagBits::eTransient : return "Transient";
3127       case CommandPoolCreateFlagBits::eResetCommandBuffer : return "ResetCommandBuffer";
3128       case CommandPoolCreateFlagBits::eProtected : return "Protected";
3129       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3130     }
3131 
3132   }
3133 
3134 
to_string(CommandPoolResetFlagBits)3135   VULKAN_HPP_INLINE std::string to_string( CommandPoolResetFlagBits )
3136   {
3137     return "(void)";
3138   }
3139 
3140 
to_string(CommandBufferLevel value)3141   VULKAN_HPP_INLINE std::string to_string( CommandBufferLevel value )
3142   {
3143     switch ( value )
3144     {
3145       case CommandBufferLevel::ePrimary : return "Primary";
3146       case CommandBufferLevel::eSecondary : return "Secondary";
3147       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3148     }
3149 
3150   }
3151 
3152 
to_string(CommandBufferResetFlagBits value)3153   VULKAN_HPP_INLINE std::string to_string( CommandBufferResetFlagBits value )
3154   {
3155     switch ( value )
3156     {
3157       case CommandBufferResetFlagBits::eReleaseResources : return "ReleaseResources";
3158       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3159     }
3160 
3161   }
3162 
3163 
to_string(CommandBufferUsageFlagBits value)3164   VULKAN_HPP_INLINE std::string to_string( CommandBufferUsageFlagBits value )
3165   {
3166     switch ( value )
3167     {
3168       case CommandBufferUsageFlagBits::eOneTimeSubmit : return "OneTimeSubmit";
3169       case CommandBufferUsageFlagBits::eRenderPassContinue : return "RenderPassContinue";
3170       case CommandBufferUsageFlagBits::eSimultaneousUse : return "SimultaneousUse";
3171       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3172     }
3173 
3174   }
3175 
3176 
to_string(QueryControlFlagBits value)3177   VULKAN_HPP_INLINE std::string to_string( QueryControlFlagBits value )
3178   {
3179     switch ( value )
3180     {
3181       case QueryControlFlagBits::ePrecise : return "Precise";
3182       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3183     }
3184 
3185   }
3186 
3187 
to_string(IndexType value)3188   VULKAN_HPP_INLINE std::string to_string( IndexType value )
3189   {
3190     switch ( value )
3191     {
3192       case IndexType::eUint16 : return "Uint16";
3193       case IndexType::eUint32 : return "Uint32";
3194       case IndexType::eUint8EXT : return "Uint8EXT";
3195       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3196     }
3197 
3198   }
3199 
3200 
to_string(StencilFaceFlagBits value)3201   VULKAN_HPP_INLINE std::string to_string( StencilFaceFlagBits value )
3202   {
3203     switch ( value )
3204     {
3205       case StencilFaceFlagBits::eFront : return "Front";
3206       case StencilFaceFlagBits::eBack : return "Back";
3207       case StencilFaceFlagBits::eFrontAndBack : return "FrontAndBack";
3208       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3209     }
3210 
3211   }
3212 
3213 
to_string(SubpassContents value)3214   VULKAN_HPP_INLINE std::string to_string( SubpassContents value )
3215   {
3216     switch ( value )
3217     {
3218       case SubpassContents::eInline : return "Inline";
3219       case SubpassContents::eSecondaryCommandBuffers : return "SecondaryCommandBuffers";
3220       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3221     }
3222 
3223   }
3224 
3225   //=== VK_VERSION_1_1 ===
3226 
3227 
to_string(SubgroupFeatureFlagBits value)3228   VULKAN_HPP_INLINE std::string to_string( SubgroupFeatureFlagBits value )
3229   {
3230     switch ( value )
3231     {
3232       case SubgroupFeatureFlagBits::eBasic : return "Basic";
3233       case SubgroupFeatureFlagBits::eVote : return "Vote";
3234       case SubgroupFeatureFlagBits::eArithmetic : return "Arithmetic";
3235       case SubgroupFeatureFlagBits::eBallot : return "Ballot";
3236       case SubgroupFeatureFlagBits::eShuffle : return "Shuffle";
3237       case SubgroupFeatureFlagBits::eShuffleRelative : return "ShuffleRelative";
3238       case SubgroupFeatureFlagBits::eClustered : return "Clustered";
3239       case SubgroupFeatureFlagBits::eQuad : return "Quad";
3240       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3241     }
3242 
3243   }
3244 
3245 
to_string(PeerMemoryFeatureFlagBits value)3246   VULKAN_HPP_INLINE std::string to_string( PeerMemoryFeatureFlagBits value )
3247   {
3248     switch ( value )
3249     {
3250       case PeerMemoryFeatureFlagBits::eCopySrc : return "CopySrc";
3251       case PeerMemoryFeatureFlagBits::eCopyDst : return "CopyDst";
3252       case PeerMemoryFeatureFlagBits::eGenericSrc : return "GenericSrc";
3253       case PeerMemoryFeatureFlagBits::eGenericDst : return "GenericDst";
3254       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3255     }
3256 
3257   }
3258 
3259 
to_string(MemoryAllocateFlagBits value)3260   VULKAN_HPP_INLINE std::string to_string( MemoryAllocateFlagBits value )
3261   {
3262     switch ( value )
3263     {
3264       case MemoryAllocateFlagBits::eDeviceMask : return "DeviceMask";
3265       case MemoryAllocateFlagBits::eDeviceAddress : return "DeviceAddress";
3266       case MemoryAllocateFlagBits::eDeviceAddressCaptureReplay : return "DeviceAddressCaptureReplay";
3267       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3268     }
3269 
3270   }
3271 
3272 
to_string(PointClippingBehavior value)3273   VULKAN_HPP_INLINE std::string to_string( PointClippingBehavior value )
3274   {
3275     switch ( value )
3276     {
3277       case PointClippingBehavior::eAllClipPlanes : return "AllClipPlanes";
3278       case PointClippingBehavior::eUserClipPlanesOnly : return "UserClipPlanesOnly";
3279       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3280     }
3281 
3282   }
3283 
3284 
to_string(TessellationDomainOrigin value)3285   VULKAN_HPP_INLINE std::string to_string( TessellationDomainOrigin value )
3286   {
3287     switch ( value )
3288     {
3289       case TessellationDomainOrigin::eUpperLeft : return "UpperLeft";
3290       case TessellationDomainOrigin::eLowerLeft : return "LowerLeft";
3291       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3292     }
3293 
3294   }
3295 
3296 
to_string(SamplerYcbcrModelConversion value)3297   VULKAN_HPP_INLINE std::string to_string( SamplerYcbcrModelConversion value )
3298   {
3299     switch ( value )
3300     {
3301       case SamplerYcbcrModelConversion::eRgbIdentity : return "RgbIdentity";
3302       case SamplerYcbcrModelConversion::eYcbcrIdentity : return "YcbcrIdentity";
3303       case SamplerYcbcrModelConversion::eYcbcr709 : return "Ycbcr709";
3304       case SamplerYcbcrModelConversion::eYcbcr601 : return "Ycbcr601";
3305       case SamplerYcbcrModelConversion::eYcbcr2020 : return "Ycbcr2020";
3306       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3307     }
3308 
3309   }
3310 
3311 
to_string(SamplerYcbcrRange value)3312   VULKAN_HPP_INLINE std::string to_string( SamplerYcbcrRange value )
3313   {
3314     switch ( value )
3315     {
3316       case SamplerYcbcrRange::eItuFull : return "ItuFull";
3317       case SamplerYcbcrRange::eItuNarrow : return "ItuNarrow";
3318       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3319     }
3320 
3321   }
3322 
3323 
to_string(ChromaLocation value)3324   VULKAN_HPP_INLINE std::string to_string( ChromaLocation value )
3325   {
3326     switch ( value )
3327     {
3328       case ChromaLocation::eCositedEven : return "CositedEven";
3329       case ChromaLocation::eMidpoint : return "Midpoint";
3330       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3331     }
3332 
3333   }
3334 
3335 
to_string(ExternalMemoryHandleTypeFlagBits value)3336   VULKAN_HPP_INLINE std::string to_string( ExternalMemoryHandleTypeFlagBits value )
3337   {
3338     switch ( value )
3339     {
3340       case ExternalMemoryHandleTypeFlagBits::eOpaqueFd : return "OpaqueFd";
3341       case ExternalMemoryHandleTypeFlagBits::eOpaqueWin32 : return "OpaqueWin32";
3342       case ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt : return "OpaqueWin32Kmt";
3343       case ExternalMemoryHandleTypeFlagBits::eD3D11Texture : return "D3D11Texture";
3344       case ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt : return "D3D11TextureKmt";
3345       case ExternalMemoryHandleTypeFlagBits::eD3D12Heap : return "D3D12Heap";
3346       case ExternalMemoryHandleTypeFlagBits::eD3D12Resource : return "D3D12Resource";
3347       case ExternalMemoryHandleTypeFlagBits::eDmaBufEXT : return "DmaBufEXT";
3348       case ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT : return "HostAllocationEXT";
3349       case ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT : return "HostMappedForeignMemoryEXT";
3350 #if defined( VK_USE_PLATFORM_SCI )
3351       case ExternalMemoryHandleTypeFlagBits::eSciBufNV : return "SciBufNV";
3352 #endif /*VK_USE_PLATFORM_SCI*/
3353 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
3354       case ExternalMemoryHandleTypeFlagBits::eScreenBufferQNX : return "ScreenBufferQNX";
3355 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
3356       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3357     }
3358 
3359   }
3360 
3361 
to_string(ExternalMemoryFeatureFlagBits value)3362   VULKAN_HPP_INLINE std::string to_string( ExternalMemoryFeatureFlagBits value )
3363   {
3364     switch ( value )
3365     {
3366       case ExternalMemoryFeatureFlagBits::eDedicatedOnly : return "DedicatedOnly";
3367       case ExternalMemoryFeatureFlagBits::eExportable : return "Exportable";
3368       case ExternalMemoryFeatureFlagBits::eImportable : return "Importable";
3369       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3370     }
3371 
3372   }
3373 
3374 
to_string(ExternalFenceHandleTypeFlagBits value)3375   VULKAN_HPP_INLINE std::string to_string( ExternalFenceHandleTypeFlagBits value )
3376   {
3377     switch ( value )
3378     {
3379       case ExternalFenceHandleTypeFlagBits::eOpaqueFd : return "OpaqueFd";
3380       case ExternalFenceHandleTypeFlagBits::eOpaqueWin32 : return "OpaqueWin32";
3381       case ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt : return "OpaqueWin32Kmt";
3382       case ExternalFenceHandleTypeFlagBits::eSyncFd : return "SyncFd";
3383 #if defined( VK_USE_PLATFORM_SCI )
3384       case ExternalFenceHandleTypeFlagBits::eSciSyncObjNV : return "SciSyncObjNV";
3385       case ExternalFenceHandleTypeFlagBits::eSciSyncFenceNV : return "SciSyncFenceNV";
3386 #endif /*VK_USE_PLATFORM_SCI*/
3387       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3388     }
3389 
3390   }
3391 
3392 
to_string(ExternalFenceFeatureFlagBits value)3393   VULKAN_HPP_INLINE std::string to_string( ExternalFenceFeatureFlagBits value )
3394   {
3395     switch ( value )
3396     {
3397       case ExternalFenceFeatureFlagBits::eExportable : return "Exportable";
3398       case ExternalFenceFeatureFlagBits::eImportable : return "Importable";
3399       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3400     }
3401 
3402   }
3403 
3404 
to_string(FenceImportFlagBits value)3405   VULKAN_HPP_INLINE std::string to_string( FenceImportFlagBits value )
3406   {
3407     switch ( value )
3408     {
3409       case FenceImportFlagBits::eTemporary : return "Temporary";
3410       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3411     }
3412 
3413   }
3414 
3415 
to_string(SemaphoreImportFlagBits value)3416   VULKAN_HPP_INLINE std::string to_string( SemaphoreImportFlagBits value )
3417   {
3418     switch ( value )
3419     {
3420       case SemaphoreImportFlagBits::eTemporary : return "Temporary";
3421       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3422     }
3423 
3424   }
3425 
3426 
to_string(ExternalSemaphoreHandleTypeFlagBits value)3427   VULKAN_HPP_INLINE std::string to_string( ExternalSemaphoreHandleTypeFlagBits value )
3428   {
3429     switch ( value )
3430     {
3431       case ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd : return "OpaqueFd";
3432       case ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32 : return "OpaqueWin32";
3433       case ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt : return "OpaqueWin32Kmt";
3434       case ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence : return "D3D12Fence";
3435       case ExternalSemaphoreHandleTypeFlagBits::eSyncFd : return "SyncFd";
3436 #if defined( VK_USE_PLATFORM_SCI )
3437       case ExternalSemaphoreHandleTypeFlagBits::eSciSyncObjNV : return "SciSyncObjNV";
3438 #endif /*VK_USE_PLATFORM_SCI*/
3439       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3440     }
3441 
3442   }
3443 
3444 
to_string(ExternalSemaphoreFeatureFlagBits value)3445   VULKAN_HPP_INLINE std::string to_string( ExternalSemaphoreFeatureFlagBits value )
3446   {
3447     switch ( value )
3448     {
3449       case ExternalSemaphoreFeatureFlagBits::eExportable : return "Exportable";
3450       case ExternalSemaphoreFeatureFlagBits::eImportable : return "Importable";
3451       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3452     }
3453 
3454   }
3455 
3456   //=== VK_VERSION_1_2 ===
3457 
3458 
to_string(DriverId value)3459   VULKAN_HPP_INLINE std::string to_string( DriverId value )
3460   {
3461     switch ( value )
3462     {
3463       case DriverId::eAmdProprietary : return "AmdProprietary";
3464       case DriverId::eAmdOpenSource : return "AmdOpenSource";
3465       case DriverId::eMesaRadv : return "MesaRadv";
3466       case DriverId::eNvidiaProprietary : return "NvidiaProprietary";
3467       case DriverId::eIntelProprietaryWindows : return "IntelProprietaryWindows";
3468       case DriverId::eIntelOpenSourceMESA : return "IntelOpenSourceMESA";
3469       case DriverId::eImaginationProprietary : return "ImaginationProprietary";
3470       case DriverId::eQualcommProprietary : return "QualcommProprietary";
3471       case DriverId::eArmProprietary : return "ArmProprietary";
3472       case DriverId::eGoogleSwiftshader : return "GoogleSwiftshader";
3473       case DriverId::eGgpProprietary : return "GgpProprietary";
3474       case DriverId::eBroadcomProprietary : return "BroadcomProprietary";
3475       case DriverId::eMesaLlvmpipe : return "MesaLlvmpipe";
3476       case DriverId::eMoltenvk : return "Moltenvk";
3477       case DriverId::eCoreaviProprietary : return "CoreaviProprietary";
3478       case DriverId::eJuiceProprietary : return "JuiceProprietary";
3479       case DriverId::eVerisiliconProprietary : return "VerisiliconProprietary";
3480       case DriverId::eMesaTurnip : return "MesaTurnip";
3481       case DriverId::eMesaV3Dv : return "MesaV3Dv";
3482       case DriverId::eMesaPanvk : return "MesaPanvk";
3483       case DriverId::eSamsungProprietary : return "SamsungProprietary";
3484       case DriverId::eMesaVenus : return "MesaVenus";
3485       case DriverId::eMesaDozen : return "MesaDozen";
3486       case DriverId::eMesaNvk : return "MesaNvk";
3487       case DriverId::eImaginationOpenSourceMESA : return "ImaginationOpenSourceMESA";
3488       case DriverId::eMesaAgxv : return "MesaAgxv";
3489       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3490     }
3491 
3492   }
3493 
3494 
to_string(ShaderFloatControlsIndependence value)3495   VULKAN_HPP_INLINE std::string to_string( ShaderFloatControlsIndependence value )
3496   {
3497     switch ( value )
3498     {
3499       case ShaderFloatControlsIndependence::e32BitOnly : return "32BitOnly";
3500       case ShaderFloatControlsIndependence::eAll : return "All";
3501       case ShaderFloatControlsIndependence::eNone : return "None";
3502       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3503     }
3504 
3505   }
3506 
3507 
to_string(DescriptorBindingFlagBits value)3508   VULKAN_HPP_INLINE std::string to_string( DescriptorBindingFlagBits value )
3509   {
3510     switch ( value )
3511     {
3512       case DescriptorBindingFlagBits::eUpdateAfterBind : return "UpdateAfterBind";
3513       case DescriptorBindingFlagBits::eUpdateUnusedWhilePending : return "UpdateUnusedWhilePending";
3514       case DescriptorBindingFlagBits::ePartiallyBound : return "PartiallyBound";
3515       case DescriptorBindingFlagBits::eVariableDescriptorCount : return "VariableDescriptorCount";
3516       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3517     }
3518 
3519   }
3520 
3521 
to_string(ResolveModeFlagBits value)3522   VULKAN_HPP_INLINE std::string to_string( ResolveModeFlagBits value )
3523   {
3524     switch ( value )
3525     {
3526       case ResolveModeFlagBits::eNone : return "None";
3527       case ResolveModeFlagBits::eSampleZero : return "SampleZero";
3528       case ResolveModeFlagBits::eAverage : return "Average";
3529       case ResolveModeFlagBits::eMin : return "Min";
3530       case ResolveModeFlagBits::eMax : return "Max";
3531       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3532     }
3533 
3534   }
3535 
3536 
to_string(SamplerReductionMode value)3537   VULKAN_HPP_INLINE std::string to_string( SamplerReductionMode value )
3538   {
3539     switch ( value )
3540     {
3541       case SamplerReductionMode::eWeightedAverage : return "WeightedAverage";
3542       case SamplerReductionMode::eMin : return "Min";
3543       case SamplerReductionMode::eMax : return "Max";
3544       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3545     }
3546 
3547   }
3548 
3549 
to_string(SemaphoreType value)3550   VULKAN_HPP_INLINE std::string to_string( SemaphoreType value )
3551   {
3552     switch ( value )
3553     {
3554       case SemaphoreType::eBinary : return "Binary";
3555       case SemaphoreType::eTimeline : return "Timeline";
3556       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3557     }
3558 
3559   }
3560 
3561 
to_string(SemaphoreWaitFlagBits value)3562   VULKAN_HPP_INLINE std::string to_string( SemaphoreWaitFlagBits value )
3563   {
3564     switch ( value )
3565     {
3566       case SemaphoreWaitFlagBits::eAny : return "Any";
3567       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3568     }
3569 
3570   }
3571 
3572   //=== VK_VERSION_1_3 ===
3573 
3574 
to_string(PipelineCreationFeedbackFlagBits value)3575   VULKAN_HPP_INLINE std::string to_string( PipelineCreationFeedbackFlagBits value )
3576   {
3577     switch ( value )
3578     {
3579       case PipelineCreationFeedbackFlagBits::eValid : return "Valid";
3580       case PipelineCreationFeedbackFlagBits::eApplicationPipelineCacheHit : return "ApplicationPipelineCacheHit";
3581       case PipelineCreationFeedbackFlagBits::eBasePipelineAcceleration : return "BasePipelineAcceleration";
3582       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3583     }
3584 
3585   }
3586 
3587 
to_string(ToolPurposeFlagBits value)3588   VULKAN_HPP_INLINE std::string to_string( ToolPurposeFlagBits value )
3589   {
3590     switch ( value )
3591     {
3592       case ToolPurposeFlagBits::eValidation : return "Validation";
3593       case ToolPurposeFlagBits::eProfiling : return "Profiling";
3594       case ToolPurposeFlagBits::eTracing : return "Tracing";
3595       case ToolPurposeFlagBits::eAdditionalFeatures : return "AdditionalFeatures";
3596       case ToolPurposeFlagBits::eModifyingFeatures : return "ModifyingFeatures";
3597       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3598     }
3599 
3600   }
3601 
3602 
to_string(PrivateDataSlotCreateFlagBits)3603   VULKAN_HPP_INLINE std::string to_string( PrivateDataSlotCreateFlagBits )
3604   {
3605     return "(void)";
3606   }
3607 
3608 
to_string(PipelineStageFlagBits2 value)3609   VULKAN_HPP_INLINE std::string to_string( PipelineStageFlagBits2 value )
3610   {
3611     switch ( value )
3612     {
3613       case PipelineStageFlagBits2::eNone : return "None";
3614       case PipelineStageFlagBits2::eTopOfPipe : return "TopOfPipe";
3615       case PipelineStageFlagBits2::eDrawIndirect : return "DrawIndirect";
3616       case PipelineStageFlagBits2::eVertexInput : return "VertexInput";
3617       case PipelineStageFlagBits2::eVertexShader : return "VertexShader";
3618       case PipelineStageFlagBits2::eTessellationControlShader : return "TessellationControlShader";
3619       case PipelineStageFlagBits2::eTessellationEvaluationShader : return "TessellationEvaluationShader";
3620       case PipelineStageFlagBits2::eGeometryShader : return "GeometryShader";
3621       case PipelineStageFlagBits2::eFragmentShader : return "FragmentShader";
3622       case PipelineStageFlagBits2::eEarlyFragmentTests : return "EarlyFragmentTests";
3623       case PipelineStageFlagBits2::eLateFragmentTests : return "LateFragmentTests";
3624       case PipelineStageFlagBits2::eColorAttachmentOutput : return "ColorAttachmentOutput";
3625       case PipelineStageFlagBits2::eComputeShader : return "ComputeShader";
3626       case PipelineStageFlagBits2::eAllTransfer : return "AllTransfer";
3627       case PipelineStageFlagBits2::eBottomOfPipe : return "BottomOfPipe";
3628       case PipelineStageFlagBits2::eHost : return "Host";
3629       case PipelineStageFlagBits2::eAllGraphics : return "AllGraphics";
3630       case PipelineStageFlagBits2::eAllCommands : return "AllCommands";
3631       case PipelineStageFlagBits2::eCopy : return "Copy";
3632       case PipelineStageFlagBits2::eResolve : return "Resolve";
3633       case PipelineStageFlagBits2::eBlit : return "Blit";
3634       case PipelineStageFlagBits2::eClear : return "Clear";
3635       case PipelineStageFlagBits2::eIndexInput : return "IndexInput";
3636       case PipelineStageFlagBits2::eVertexAttributeInput : return "VertexAttributeInput";
3637       case PipelineStageFlagBits2::ePreRasterizationShaders : return "PreRasterizationShaders";
3638       case PipelineStageFlagBits2::eTransformFeedbackEXT : return "TransformFeedbackEXT";
3639       case PipelineStageFlagBits2::eConditionalRenderingEXT : return "ConditionalRenderingEXT";
3640       case PipelineStageFlagBits2::eCommandPreprocessNV : return "CommandPreprocessNV";
3641       case PipelineStageFlagBits2::eFragmentShadingRateAttachmentKHR : return "FragmentShadingRateAttachmentKHR";
3642       case PipelineStageFlagBits2::eAccelerationStructureBuildKHR : return "AccelerationStructureBuildKHR";
3643       case PipelineStageFlagBits2::eRayTracingShaderKHR : return "RayTracingShaderKHR";
3644       case PipelineStageFlagBits2::eFragmentDensityProcessEXT : return "FragmentDensityProcessEXT";
3645       case PipelineStageFlagBits2::eTaskShaderEXT : return "TaskShaderEXT";
3646       case PipelineStageFlagBits2::eMeshShaderEXT : return "MeshShaderEXT";
3647       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3648     }
3649 
3650   }
3651 
3652 
to_string(AccessFlagBits2 value)3653   VULKAN_HPP_INLINE std::string to_string( AccessFlagBits2 value )
3654   {
3655     switch ( value )
3656     {
3657       case AccessFlagBits2::eNone : return "None";
3658       case AccessFlagBits2::eIndirectCommandRead : return "IndirectCommandRead";
3659       case AccessFlagBits2::eIndexRead : return "IndexRead";
3660       case AccessFlagBits2::eVertexAttributeRead : return "VertexAttributeRead";
3661       case AccessFlagBits2::eUniformRead : return "UniformRead";
3662       case AccessFlagBits2::eInputAttachmentRead : return "InputAttachmentRead";
3663       case AccessFlagBits2::eShaderRead : return "ShaderRead";
3664       case AccessFlagBits2::eShaderWrite : return "ShaderWrite";
3665       case AccessFlagBits2::eColorAttachmentRead : return "ColorAttachmentRead";
3666       case AccessFlagBits2::eColorAttachmentWrite : return "ColorAttachmentWrite";
3667       case AccessFlagBits2::eDepthStencilAttachmentRead : return "DepthStencilAttachmentRead";
3668       case AccessFlagBits2::eDepthStencilAttachmentWrite : return "DepthStencilAttachmentWrite";
3669       case AccessFlagBits2::eTransferRead : return "TransferRead";
3670       case AccessFlagBits2::eTransferWrite : return "TransferWrite";
3671       case AccessFlagBits2::eHostRead : return "HostRead";
3672       case AccessFlagBits2::eHostWrite : return "HostWrite";
3673       case AccessFlagBits2::eMemoryRead : return "MemoryRead";
3674       case AccessFlagBits2::eMemoryWrite : return "MemoryWrite";
3675       case AccessFlagBits2::eShaderSampledRead : return "ShaderSampledRead";
3676       case AccessFlagBits2::eShaderStorageRead : return "ShaderStorageRead";
3677       case AccessFlagBits2::eShaderStorageWrite : return "ShaderStorageWrite";
3678       case AccessFlagBits2::eTransformFeedbackWriteEXT : return "TransformFeedbackWriteEXT";
3679       case AccessFlagBits2::eTransformFeedbackCounterReadEXT : return "TransformFeedbackCounterReadEXT";
3680       case AccessFlagBits2::eTransformFeedbackCounterWriteEXT : return "TransformFeedbackCounterWriteEXT";
3681       case AccessFlagBits2::eConditionalRenderingReadEXT : return "ConditionalRenderingReadEXT";
3682       case AccessFlagBits2::eCommandPreprocessReadNV : return "CommandPreprocessReadNV";
3683       case AccessFlagBits2::eCommandPreprocessWriteNV : return "CommandPreprocessWriteNV";
3684       case AccessFlagBits2::eFragmentShadingRateAttachmentReadKHR : return "FragmentShadingRateAttachmentReadKHR";
3685       case AccessFlagBits2::eAccelerationStructureReadKHR : return "AccelerationStructureReadKHR";
3686       case AccessFlagBits2::eAccelerationStructureWriteKHR : return "AccelerationStructureWriteKHR";
3687       case AccessFlagBits2::eFragmentDensityMapReadEXT : return "FragmentDensityMapReadEXT";
3688       case AccessFlagBits2::eColorAttachmentReadNoncoherentEXT : return "ColorAttachmentReadNoncoherentEXT";
3689       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3690     }
3691 
3692   }
3693 
3694 
to_string(SubmitFlagBits value)3695   VULKAN_HPP_INLINE std::string to_string( SubmitFlagBits value )
3696   {
3697     switch ( value )
3698     {
3699       case SubmitFlagBits::eProtected : return "Protected";
3700       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3701     }
3702 
3703   }
3704 
3705 
to_string(RenderingFlagBits value)3706   VULKAN_HPP_INLINE std::string to_string( RenderingFlagBits value )
3707   {
3708     switch ( value )
3709     {
3710       case RenderingFlagBits::eContentsSecondaryCommandBuffers : return "ContentsSecondaryCommandBuffers";
3711       case RenderingFlagBits::eSuspending : return "Suspending";
3712       case RenderingFlagBits::eResuming : return "Resuming";
3713       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3714     }
3715 
3716   }
3717 
3718 
to_string(FormatFeatureFlagBits2 value)3719   VULKAN_HPP_INLINE std::string to_string( FormatFeatureFlagBits2 value )
3720   {
3721     switch ( value )
3722     {
3723       case FormatFeatureFlagBits2::eSampledImage : return "SampledImage";
3724       case FormatFeatureFlagBits2::eStorageImage : return "StorageImage";
3725       case FormatFeatureFlagBits2::eStorageImageAtomic : return "StorageImageAtomic";
3726       case FormatFeatureFlagBits2::eUniformTexelBuffer : return "UniformTexelBuffer";
3727       case FormatFeatureFlagBits2::eStorageTexelBuffer : return "StorageTexelBuffer";
3728       case FormatFeatureFlagBits2::eStorageTexelBufferAtomic : return "StorageTexelBufferAtomic";
3729       case FormatFeatureFlagBits2::eVertexBuffer : return "VertexBuffer";
3730       case FormatFeatureFlagBits2::eColorAttachment : return "ColorAttachment";
3731       case FormatFeatureFlagBits2::eColorAttachmentBlend : return "ColorAttachmentBlend";
3732       case FormatFeatureFlagBits2::eDepthStencilAttachment : return "DepthStencilAttachment";
3733       case FormatFeatureFlagBits2::eBlitSrc : return "BlitSrc";
3734       case FormatFeatureFlagBits2::eBlitDst : return "BlitDst";
3735       case FormatFeatureFlagBits2::eSampledImageFilterLinear : return "SampledImageFilterLinear";
3736       case FormatFeatureFlagBits2::eSampledImageFilterCubic : return "SampledImageFilterCubic";
3737       case FormatFeatureFlagBits2::eTransferSrc : return "TransferSrc";
3738       case FormatFeatureFlagBits2::eTransferDst : return "TransferDst";
3739       case FormatFeatureFlagBits2::eSampledImageFilterMinmax : return "SampledImageFilterMinmax";
3740       case FormatFeatureFlagBits2::eMidpointChromaSamples : return "MidpointChromaSamples";
3741       case FormatFeatureFlagBits2::eSampledImageYcbcrConversionLinearFilter : return "SampledImageYcbcrConversionLinearFilter";
3742       case FormatFeatureFlagBits2::eSampledImageYcbcrConversionSeparateReconstructionFilter : return "SampledImageYcbcrConversionSeparateReconstructionFilter";
3743       case FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicit : return "SampledImageYcbcrConversionChromaReconstructionExplicit";
3744       case FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable : return "SampledImageYcbcrConversionChromaReconstructionExplicitForceable";
3745       case FormatFeatureFlagBits2::eDisjoint : return "Disjoint";
3746       case FormatFeatureFlagBits2::eCositedChromaSamples : return "CositedChromaSamples";
3747       case FormatFeatureFlagBits2::eStorageReadWithoutFormat : return "StorageReadWithoutFormat";
3748       case FormatFeatureFlagBits2::eStorageWriteWithoutFormat : return "StorageWriteWithoutFormat";
3749       case FormatFeatureFlagBits2::eSampledImageDepthComparison : return "SampledImageDepthComparison";
3750       case FormatFeatureFlagBits2::eFragmentShadingRateAttachmentKHR : return "FragmentShadingRateAttachmentKHR";
3751       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3752     }
3753 
3754   }
3755 
3756   //=== VKSC_VERSION_1_0 ===
3757 
3758 
to_string(FaultLevel value)3759   VULKAN_HPP_INLINE std::string to_string( FaultLevel value )
3760   {
3761     switch ( value )
3762     {
3763       case FaultLevel::eUnassigned : return "Unassigned";
3764       case FaultLevel::eCritical : return "Critical";
3765       case FaultLevel::eRecoverable : return "Recoverable";
3766       case FaultLevel::eWarning : return "Warning";
3767       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3768     }
3769 
3770   }
3771 
3772 
to_string(FaultType value)3773   VULKAN_HPP_INLINE std::string to_string( FaultType value )
3774   {
3775     switch ( value )
3776     {
3777       case FaultType::eInvalid : return "Invalid";
3778       case FaultType::eUnassigned : return "Unassigned";
3779       case FaultType::eImplementation : return "Implementation";
3780       case FaultType::eSystem : return "System";
3781       case FaultType::ePhysicalDevice : return "PhysicalDevice";
3782       case FaultType::eCommandBufferFull : return "CommandBufferFull";
3783       case FaultType::eInvalidApiUsage : return "InvalidApiUsage";
3784       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3785     }
3786 
3787   }
3788 
3789 
to_string(FaultQueryBehavior value)3790   VULKAN_HPP_INLINE std::string to_string( FaultQueryBehavior value )
3791   {
3792     switch ( value )
3793     {
3794       case FaultQueryBehavior::eGetAndClearAllFaults : return "GetAndClearAllFaults";
3795       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3796     }
3797 
3798   }
3799 
3800 
to_string(PipelineMatchControl value)3801   VULKAN_HPP_INLINE std::string to_string( PipelineMatchControl value )
3802   {
3803     switch ( value )
3804     {
3805       case PipelineMatchControl::eApplicationUuidExactMatch : return "ApplicationUuidExactMatch";
3806       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3807     }
3808 
3809   }
3810 
3811 
to_string(PipelineCacheValidationVersion value)3812   VULKAN_HPP_INLINE std::string to_string( PipelineCacheValidationVersion value )
3813   {
3814     switch ( value )
3815     {
3816       case PipelineCacheValidationVersion::eSafetyCriticalOne : return "SafetyCriticalOne";
3817       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3818     }
3819 
3820   }
3821 
3822   //=== VK_KHR_surface ===
3823 
3824 
to_string(SurfaceTransformFlagBitsKHR value)3825   VULKAN_HPP_INLINE std::string to_string( SurfaceTransformFlagBitsKHR value )
3826   {
3827     switch ( value )
3828     {
3829       case SurfaceTransformFlagBitsKHR::eIdentity : return "Identity";
3830       case SurfaceTransformFlagBitsKHR::eRotate90 : return "Rotate90";
3831       case SurfaceTransformFlagBitsKHR::eRotate180 : return "Rotate180";
3832       case SurfaceTransformFlagBitsKHR::eRotate270 : return "Rotate270";
3833       case SurfaceTransformFlagBitsKHR::eHorizontalMirror : return "HorizontalMirror";
3834       case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90 : return "HorizontalMirrorRotate90";
3835       case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180 : return "HorizontalMirrorRotate180";
3836       case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270 : return "HorizontalMirrorRotate270";
3837       case SurfaceTransformFlagBitsKHR::eInherit : return "Inherit";
3838       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3839     }
3840 
3841   }
3842 
3843 
to_string(PresentModeKHR value)3844   VULKAN_HPP_INLINE std::string to_string( PresentModeKHR value )
3845   {
3846     switch ( value )
3847     {
3848       case PresentModeKHR::eImmediate : return "Immediate";
3849       case PresentModeKHR::eMailbox : return "Mailbox";
3850       case PresentModeKHR::eFifo : return "Fifo";
3851       case PresentModeKHR::eFifoRelaxed : return "FifoRelaxed";
3852       case PresentModeKHR::eSharedDemandRefresh : return "SharedDemandRefresh";
3853       case PresentModeKHR::eSharedContinuousRefresh : return "SharedContinuousRefresh";
3854       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3855     }
3856 
3857   }
3858 
3859 
to_string(ColorSpaceKHR value)3860   VULKAN_HPP_INLINE std::string to_string( ColorSpaceKHR value )
3861   {
3862     switch ( value )
3863     {
3864       case ColorSpaceKHR::eSrgbNonlinear : return "SrgbNonlinear";
3865       case ColorSpaceKHR::eDisplayP3NonlinearEXT : return "DisplayP3NonlinearEXT";
3866       case ColorSpaceKHR::eExtendedSrgbLinearEXT : return "ExtendedSrgbLinearEXT";
3867       case ColorSpaceKHR::eDisplayP3LinearEXT : return "DisplayP3LinearEXT";
3868       case ColorSpaceKHR::eDciP3NonlinearEXT : return "DciP3NonlinearEXT";
3869       case ColorSpaceKHR::eBt709LinearEXT : return "Bt709LinearEXT";
3870       case ColorSpaceKHR::eBt709NonlinearEXT : return "Bt709NonlinearEXT";
3871       case ColorSpaceKHR::eBt2020LinearEXT : return "Bt2020LinearEXT";
3872       case ColorSpaceKHR::eHdr10St2084EXT : return "Hdr10St2084EXT";
3873       case ColorSpaceKHR::eDolbyvisionEXT : return "DolbyvisionEXT";
3874       case ColorSpaceKHR::eHdr10HlgEXT : return "Hdr10HlgEXT";
3875       case ColorSpaceKHR::eAdobergbLinearEXT : return "AdobergbLinearEXT";
3876       case ColorSpaceKHR::eAdobergbNonlinearEXT : return "AdobergbNonlinearEXT";
3877       case ColorSpaceKHR::ePassThroughEXT : return "PassThroughEXT";
3878       case ColorSpaceKHR::eExtendedSrgbNonlinearEXT : return "ExtendedSrgbNonlinearEXT";
3879       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3880     }
3881 
3882   }
3883 
3884 
to_string(CompositeAlphaFlagBitsKHR value)3885   VULKAN_HPP_INLINE std::string to_string( CompositeAlphaFlagBitsKHR value )
3886   {
3887     switch ( value )
3888     {
3889       case CompositeAlphaFlagBitsKHR::eOpaque : return "Opaque";
3890       case CompositeAlphaFlagBitsKHR::ePreMultiplied : return "PreMultiplied";
3891       case CompositeAlphaFlagBitsKHR::ePostMultiplied : return "PostMultiplied";
3892       case CompositeAlphaFlagBitsKHR::eInherit : return "Inherit";
3893       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3894     }
3895 
3896   }
3897 
3898   //=== VK_KHR_swapchain ===
3899 
3900 
to_string(SwapchainCreateFlagBitsKHR value)3901   VULKAN_HPP_INLINE std::string to_string( SwapchainCreateFlagBitsKHR value )
3902   {
3903     switch ( value )
3904     {
3905       case SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions : return "SplitInstanceBindRegions";
3906       case SwapchainCreateFlagBitsKHR::eProtected : return "Protected";
3907       case SwapchainCreateFlagBitsKHR::eMutableFormat : return "MutableFormat";
3908       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3909     }
3910 
3911   }
3912 
3913 
to_string(DeviceGroupPresentModeFlagBitsKHR value)3914   VULKAN_HPP_INLINE std::string to_string( DeviceGroupPresentModeFlagBitsKHR value )
3915   {
3916     switch ( value )
3917     {
3918       case DeviceGroupPresentModeFlagBitsKHR::eLocal : return "Local";
3919       case DeviceGroupPresentModeFlagBitsKHR::eRemote : return "Remote";
3920       case DeviceGroupPresentModeFlagBitsKHR::eSum : return "Sum";
3921       case DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice : return "LocalMultiDevice";
3922       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3923     }
3924 
3925   }
3926 
3927   //=== VK_KHR_display ===
3928 
3929 
to_string(DisplayPlaneAlphaFlagBitsKHR value)3930   VULKAN_HPP_INLINE std::string to_string( DisplayPlaneAlphaFlagBitsKHR value )
3931   {
3932     switch ( value )
3933     {
3934       case DisplayPlaneAlphaFlagBitsKHR::eOpaque : return "Opaque";
3935       case DisplayPlaneAlphaFlagBitsKHR::eGlobal : return "Global";
3936       case DisplayPlaneAlphaFlagBitsKHR::ePerPixel : return "PerPixel";
3937       case DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied : return "PerPixelPremultiplied";
3938       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3939     }
3940 
3941   }
3942 
3943 
to_string(DisplayModeCreateFlagBitsKHR)3944   VULKAN_HPP_INLINE std::string to_string( DisplayModeCreateFlagBitsKHR )
3945   {
3946     return "(void)";
3947   }
3948 
3949 
to_string(DisplaySurfaceCreateFlagBitsKHR)3950   VULKAN_HPP_INLINE std::string to_string( DisplaySurfaceCreateFlagBitsKHR )
3951   {
3952     return "(void)";
3953   }
3954 
3955   //=== VK_EXT_display_surface_counter ===
3956 
3957 
to_string(SurfaceCounterFlagBitsEXT value)3958   VULKAN_HPP_INLINE std::string to_string( SurfaceCounterFlagBitsEXT value )
3959   {
3960     switch ( value )
3961     {
3962       case SurfaceCounterFlagBitsEXT::eVblank : return "Vblank";
3963       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3964     }
3965 
3966   }
3967 
3968   //=== VK_EXT_display_control ===
3969 
3970 
to_string(DisplayPowerStateEXT value)3971   VULKAN_HPP_INLINE std::string to_string( DisplayPowerStateEXT value )
3972   {
3973     switch ( value )
3974     {
3975       case DisplayPowerStateEXT::eOff : return "Off";
3976       case DisplayPowerStateEXT::eSuspend : return "Suspend";
3977       case DisplayPowerStateEXT::eOn : return "On";
3978       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3979     }
3980 
3981   }
3982 
3983 
to_string(DeviceEventTypeEXT value)3984   VULKAN_HPP_INLINE std::string to_string( DeviceEventTypeEXT value )
3985   {
3986     switch ( value )
3987     {
3988       case DeviceEventTypeEXT::eDisplayHotplug : return "DisplayHotplug";
3989       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
3990     }
3991 
3992   }
3993 
3994 
to_string(DisplayEventTypeEXT value)3995   VULKAN_HPP_INLINE std::string to_string( DisplayEventTypeEXT value )
3996   {
3997     switch ( value )
3998     {
3999       case DisplayEventTypeEXT::eFirstPixelOut : return "FirstPixelOut";
4000       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
4001     }
4002 
4003   }
4004 
4005   //=== VK_EXT_discard_rectangles ===
4006 
4007 
to_string(DiscardRectangleModeEXT value)4008   VULKAN_HPP_INLINE std::string to_string( DiscardRectangleModeEXT value )
4009   {
4010     switch ( value )
4011     {
4012       case DiscardRectangleModeEXT::eInclusive : return "Inclusive";
4013       case DiscardRectangleModeEXT::eExclusive : return "Exclusive";
4014       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
4015     }
4016 
4017   }
4018 
4019 
to_string(PipelineDiscardRectangleStateCreateFlagBitsEXT)4020   VULKAN_HPP_INLINE std::string to_string( PipelineDiscardRectangleStateCreateFlagBitsEXT )
4021   {
4022     return "(void)";
4023   }
4024 
4025   //=== VK_EXT_conservative_rasterization ===
4026 
4027 
to_string(ConservativeRasterizationModeEXT value)4028   VULKAN_HPP_INLINE std::string to_string( ConservativeRasterizationModeEXT value )
4029   {
4030     switch ( value )
4031     {
4032       case ConservativeRasterizationModeEXT::eDisabled : return "Disabled";
4033       case ConservativeRasterizationModeEXT::eOverestimate : return "Overestimate";
4034       case ConservativeRasterizationModeEXT::eUnderestimate : return "Underestimate";
4035       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
4036     }
4037 
4038   }
4039 
4040 
to_string(PipelineRasterizationConservativeStateCreateFlagBitsEXT)4041   VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationConservativeStateCreateFlagBitsEXT )
4042   {
4043     return "(void)";
4044   }
4045 
4046   //=== VK_EXT_depth_clip_enable ===
4047 
4048 
to_string(PipelineRasterizationDepthClipStateCreateFlagBitsEXT)4049   VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationDepthClipStateCreateFlagBitsEXT )
4050   {
4051     return "(void)";
4052   }
4053 
4054   //=== VK_KHR_performance_query ===
4055 
4056 
to_string(PerformanceCounterDescriptionFlagBitsKHR value)4057   VULKAN_HPP_INLINE std::string to_string( PerformanceCounterDescriptionFlagBitsKHR value )
4058   {
4059     switch ( value )
4060     {
4061       case PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting : return "PerformanceImpacting";
4062       case PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted : return "ConcurrentlyImpacted";
4063       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
4064     }
4065 
4066   }
4067 
4068 
to_string(PerformanceCounterScopeKHR value)4069   VULKAN_HPP_INLINE std::string to_string( PerformanceCounterScopeKHR value )
4070   {
4071     switch ( value )
4072     {
4073       case PerformanceCounterScopeKHR::eCommandBuffer : return "CommandBuffer";
4074       case PerformanceCounterScopeKHR::eRenderPass : return "RenderPass";
4075       case PerformanceCounterScopeKHR::eCommand : return "Command";
4076       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
4077     }
4078 
4079   }
4080 
4081 
to_string(PerformanceCounterStorageKHR value)4082   VULKAN_HPP_INLINE std::string to_string( PerformanceCounterStorageKHR value )
4083   {
4084     switch ( value )
4085     {
4086       case PerformanceCounterStorageKHR::eInt32 : return "Int32";
4087       case PerformanceCounterStorageKHR::eInt64 : return "Int64";
4088       case PerformanceCounterStorageKHR::eUint32 : return "Uint32";
4089       case PerformanceCounterStorageKHR::eUint64 : return "Uint64";
4090       case PerformanceCounterStorageKHR::eFloat32 : return "Float32";
4091       case PerformanceCounterStorageKHR::eFloat64 : return "Float64";
4092       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
4093     }
4094 
4095   }
4096 
4097 
to_string(PerformanceCounterUnitKHR value)4098   VULKAN_HPP_INLINE std::string to_string( PerformanceCounterUnitKHR value )
4099   {
4100     switch ( value )
4101     {
4102       case PerformanceCounterUnitKHR::eGeneric : return "Generic";
4103       case PerformanceCounterUnitKHR::ePercentage : return "Percentage";
4104       case PerformanceCounterUnitKHR::eNanoseconds : return "Nanoseconds";
4105       case PerformanceCounterUnitKHR::eBytes : return "Bytes";
4106       case PerformanceCounterUnitKHR::eBytesPerSecond : return "BytesPerSecond";
4107       case PerformanceCounterUnitKHR::eKelvin : return "Kelvin";
4108       case PerformanceCounterUnitKHR::eWatts : return "Watts";
4109       case PerformanceCounterUnitKHR::eVolts : return "Volts";
4110       case PerformanceCounterUnitKHR::eAmps : return "Amps";
4111       case PerformanceCounterUnitKHR::eHertz : return "Hertz";
4112       case PerformanceCounterUnitKHR::eCycles : return "Cycles";
4113       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
4114     }
4115 
4116   }
4117 
4118 
to_string(AcquireProfilingLockFlagBitsKHR)4119   VULKAN_HPP_INLINE std::string to_string( AcquireProfilingLockFlagBitsKHR )
4120   {
4121     return "(void)";
4122   }
4123 
4124   //=== VK_EXT_debug_utils ===
4125 
4126 
to_string(DebugUtilsMessageSeverityFlagBitsEXT value)4127   VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessageSeverityFlagBitsEXT value )
4128   {
4129     switch ( value )
4130     {
4131       case DebugUtilsMessageSeverityFlagBitsEXT::eVerbose : return "Verbose";
4132       case DebugUtilsMessageSeverityFlagBitsEXT::eInfo : return "Info";
4133       case DebugUtilsMessageSeverityFlagBitsEXT::eWarning : return "Warning";
4134       case DebugUtilsMessageSeverityFlagBitsEXT::eError : return "Error";
4135       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
4136     }
4137 
4138   }
4139 
4140 
to_string(DebugUtilsMessageTypeFlagBitsEXT value)4141   VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessageTypeFlagBitsEXT value )
4142   {
4143     switch ( value )
4144     {
4145       case DebugUtilsMessageTypeFlagBitsEXT::eGeneral : return "General";
4146       case DebugUtilsMessageTypeFlagBitsEXT::eValidation : return "Validation";
4147       case DebugUtilsMessageTypeFlagBitsEXT::ePerformance : return "Performance";
4148       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
4149     }
4150 
4151   }
4152 
4153 
to_string(DebugUtilsMessengerCallbackDataFlagBitsEXT)4154   VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCallbackDataFlagBitsEXT )
4155   {
4156     return "(void)";
4157   }
4158 
4159 
to_string(DebugUtilsMessengerCreateFlagBitsEXT)4160   VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCreateFlagBitsEXT )
4161   {
4162     return "(void)";
4163   }
4164 
4165   //=== VK_EXT_blend_operation_advanced ===
4166 
4167 
to_string(BlendOverlapEXT value)4168   VULKAN_HPP_INLINE std::string to_string( BlendOverlapEXT value )
4169   {
4170     switch ( value )
4171     {
4172       case BlendOverlapEXT::eUncorrelated : return "Uncorrelated";
4173       case BlendOverlapEXT::eDisjoint : return "Disjoint";
4174       case BlendOverlapEXT::eConjoint : return "Conjoint";
4175       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
4176     }
4177 
4178   }
4179 
4180   //=== VK_EXT_calibrated_timestamps ===
4181 
4182 
to_string(TimeDomainEXT value)4183   VULKAN_HPP_INLINE std::string to_string( TimeDomainEXT value )
4184   {
4185     switch ( value )
4186     {
4187       case TimeDomainEXT::eDevice : return "Device";
4188       case TimeDomainEXT::eClockMonotonic : return "ClockMonotonic";
4189       case TimeDomainEXT::eClockMonotonicRaw : return "ClockMonotonicRaw";
4190       case TimeDomainEXT::eQueryPerformanceCounter : return "QueryPerformanceCounter";
4191       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
4192     }
4193 
4194   }
4195 
4196   //=== VK_KHR_fragment_shading_rate ===
4197 
4198 
to_string(FragmentShadingRateCombinerOpKHR value)4199   VULKAN_HPP_INLINE std::string to_string( FragmentShadingRateCombinerOpKHR value )
4200   {
4201     switch ( value )
4202     {
4203       case FragmentShadingRateCombinerOpKHR::eKeep : return "Keep";
4204       case FragmentShadingRateCombinerOpKHR::eReplace : return "Replace";
4205       case FragmentShadingRateCombinerOpKHR::eMin : return "Min";
4206       case FragmentShadingRateCombinerOpKHR::eMax : return "Max";
4207       case FragmentShadingRateCombinerOpKHR::eMul : return "Mul";
4208       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
4209     }
4210 
4211   }
4212 
4213   //=== VK_EXT_validation_features ===
4214 
4215 
to_string(ValidationFeatureEnableEXT value)4216   VULKAN_HPP_INLINE std::string to_string( ValidationFeatureEnableEXT value )
4217   {
4218     switch ( value )
4219     {
4220       case ValidationFeatureEnableEXT::eGpuAssisted : return "GpuAssisted";
4221       case ValidationFeatureEnableEXT::eGpuAssistedReserveBindingSlot : return "GpuAssistedReserveBindingSlot";
4222       case ValidationFeatureEnableEXT::eBestPractices : return "BestPractices";
4223       case ValidationFeatureEnableEXT::eDebugPrintf : return "DebugPrintf";
4224       case ValidationFeatureEnableEXT::eSynchronizationValidation : return "SynchronizationValidation";
4225       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
4226     }
4227 
4228   }
4229 
4230 
to_string(ValidationFeatureDisableEXT value)4231   VULKAN_HPP_INLINE std::string to_string( ValidationFeatureDisableEXT value )
4232   {
4233     switch ( value )
4234     {
4235       case ValidationFeatureDisableEXT::eAll : return "All";
4236       case ValidationFeatureDisableEXT::eShaders : return "Shaders";
4237       case ValidationFeatureDisableEXT::eThreadSafety : return "ThreadSafety";
4238       case ValidationFeatureDisableEXT::eApiParameters : return "ApiParameters";
4239       case ValidationFeatureDisableEXT::eObjectLifetimes : return "ObjectLifetimes";
4240       case ValidationFeatureDisableEXT::eCoreChecks : return "CoreChecks";
4241       case ValidationFeatureDisableEXT::eUniqueHandles : return "UniqueHandles";
4242       case ValidationFeatureDisableEXT::eShaderValidationCache : return "ShaderValidationCache";
4243       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
4244     }
4245 
4246   }
4247 
4248   //=== VK_EXT_headless_surface ===
4249 
4250 
to_string(HeadlessSurfaceCreateFlagBitsEXT)4251   VULKAN_HPP_INLINE std::string to_string( HeadlessSurfaceCreateFlagBitsEXT )
4252   {
4253     return "(void)";
4254   }
4255 
4256   //=== VK_EXT_line_rasterization ===
4257 
4258 
to_string(LineRasterizationModeEXT value)4259   VULKAN_HPP_INLINE std::string to_string( LineRasterizationModeEXT value )
4260   {
4261     switch ( value )
4262     {
4263       case LineRasterizationModeEXT::eDefault : return "Default";
4264       case LineRasterizationModeEXT::eRectangular : return "Rectangular";
4265       case LineRasterizationModeEXT::eBresenham : return "Bresenham";
4266       case LineRasterizationModeEXT::eRectangularSmooth : return "RectangularSmooth";
4267       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
4268     }
4269 
4270   }
4271 
4272   //=== VK_KHR_object_refresh ===
4273 
4274 
to_string(RefreshObjectFlagBitsKHR)4275   VULKAN_HPP_INLINE std::string to_string( RefreshObjectFlagBitsKHR )
4276   {
4277     return "(void)";
4278   }
4279 
4280 #if defined( VK_USE_PLATFORM_SCI )
4281   //=== VK_NV_external_sci_sync ===
4282 
4283 
to_string(SciSyncClientTypeNV value)4284   VULKAN_HPP_INLINE std::string to_string( SciSyncClientTypeNV value )
4285   {
4286     switch ( value )
4287     {
4288       case SciSyncClientTypeNV::eSignaler : return "Signaler";
4289       case SciSyncClientTypeNV::eWaiter : return "Waiter";
4290       case SciSyncClientTypeNV::eSignalerWaiter : return "SignalerWaiter";
4291       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
4292     }
4293 
4294   }
4295 
4296 
to_string(SciSyncPrimitiveTypeNV value)4297   VULKAN_HPP_INLINE std::string to_string( SciSyncPrimitiveTypeNV value )
4298   {
4299     switch ( value )
4300     {
4301       case SciSyncPrimitiveTypeNV::eFence : return "Fence";
4302       case SciSyncPrimitiveTypeNV::eSemaphore : return "Semaphore";
4303       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
4304     }
4305 
4306   }
4307 #endif /*VK_USE_PLATFORM_SCI*/
4308 
4309 
4310 } // namespace VULKAN_HPP_NAMESPACE
4311 #endif
4312