|
1501
|
1 // Copyright 2015-2025 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 #if !defined( VULKAN_HPP_CXX_MODULE )
|
|
|
12 # include <vulkan/vulkan.hpp>
|
|
|
13 #endif
|
|
|
14
|
|
|
15 // ignore warnings on using deprecated enum values in this header
|
|
|
16 #if defined( __clang__ ) || defined( __GNUC__ )
|
|
|
17 # pragma GCC diagnostic push
|
|
|
18 # pragma GCC diagnostic ignored "-Wdeprecated-declarations"
|
|
|
19 #elif defined( _MSC_VER )
|
|
|
20 # pragma warning( push )
|
|
|
21 # pragma warning( disable : 4996 )
|
|
|
22 #endif
|
|
|
23
|
|
|
24 #if !defined( VULKAN_HPP_CXX_MODULE )
|
|
|
25 # if defined( __cpp_lib_format )
|
|
|
26 # include <format> // std::format
|
|
|
27 # else
|
|
|
28 # include <sstream> // std::stringstream
|
|
|
29 # endif
|
|
|
30 #endif
|
|
|
31
|
|
|
32 namespace VULKAN_HPP_NAMESPACE
|
|
|
33 {
|
|
|
34
|
|
|
35 //==========================
|
|
|
36 //=== BITMASKs to_string ===
|
|
|
37 //==========================
|
|
|
38
|
|
|
39 //=== VK_VERSION_1_0 ===
|
|
|
40
|
|
|
41 VULKAN_HPP_INLINE std::string to_string( FormatFeatureFlags value )
|
|
|
42 {
|
|
|
43 std::string result = "{";
|
|
|
44 if ( value & FormatFeatureFlagBits::eSampledImage )
|
|
|
45 result += " SampledImage |";
|
|
|
46 if ( value & FormatFeatureFlagBits::eStorageImage )
|
|
|
47 result += " StorageImage |";
|
|
|
48 if ( value & FormatFeatureFlagBits::eStorageImageAtomic )
|
|
|
49 result += " StorageImageAtomic |";
|
|
|
50 if ( value & FormatFeatureFlagBits::eUniformTexelBuffer )
|
|
|
51 result += " UniformTexelBuffer |";
|
|
|
52 if ( value & FormatFeatureFlagBits::eStorageTexelBuffer )
|
|
|
53 result += " StorageTexelBuffer |";
|
|
|
54 if ( value & FormatFeatureFlagBits::eStorageTexelBufferAtomic )
|
|
|
55 result += " StorageTexelBufferAtomic |";
|
|
|
56 if ( value & FormatFeatureFlagBits::eVertexBuffer )
|
|
|
57 result += " VertexBuffer |";
|
|
|
58 if ( value & FormatFeatureFlagBits::eColorAttachment )
|
|
|
59 result += " ColorAttachment |";
|
|
|
60 if ( value & FormatFeatureFlagBits::eColorAttachmentBlend )
|
|
|
61 result += " ColorAttachmentBlend |";
|
|
|
62 if ( value & FormatFeatureFlagBits::eDepthStencilAttachment )
|
|
|
63 result += " DepthStencilAttachment |";
|
|
|
64 if ( value & FormatFeatureFlagBits::eBlitSrc )
|
|
|
65 result += " BlitSrc |";
|
|
|
66 if ( value & FormatFeatureFlagBits::eBlitDst )
|
|
|
67 result += " BlitDst |";
|
|
|
68 if ( value & FormatFeatureFlagBits::eSampledImageFilterLinear )
|
|
|
69 result += " SampledImageFilterLinear |";
|
|
|
70 if ( value & FormatFeatureFlagBits::eTransferSrc )
|
|
|
71 result += " TransferSrc |";
|
|
|
72 if ( value & FormatFeatureFlagBits::eTransferDst )
|
|
|
73 result += " TransferDst |";
|
|
|
74 if ( value & FormatFeatureFlagBits::eMidpointChromaSamples )
|
|
|
75 result += " MidpointChromaSamples |";
|
|
|
76 if ( value & FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter )
|
|
|
77 result += " SampledImageYcbcrConversionLinearFilter |";
|
|
|
78 if ( value & FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter )
|
|
|
79 result += " SampledImageYcbcrConversionSeparateReconstructionFilter |";
|
|
|
80 if ( value & FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit )
|
|
|
81 result += " SampledImageYcbcrConversionChromaReconstructionExplicit |";
|
|
|
82 if ( value & FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable )
|
|
|
83 result += " SampledImageYcbcrConversionChromaReconstructionExplicitForceable |";
|
|
|
84 if ( value & FormatFeatureFlagBits::eDisjoint )
|
|
|
85 result += " Disjoint |";
|
|
|
86 if ( value & FormatFeatureFlagBits::eCositedChromaSamples )
|
|
|
87 result += " CositedChromaSamples |";
|
|
|
88 if ( value & FormatFeatureFlagBits::eSampledImageFilterMinmax )
|
|
|
89 result += " SampledImageFilterMinmax |";
|
|
|
90 if ( value & FormatFeatureFlagBits::eVideoDecodeOutputKHR )
|
|
|
91 result += " VideoDecodeOutputKHR |";
|
|
|
92 if ( value & FormatFeatureFlagBits::eVideoDecodeDpbKHR )
|
|
|
93 result += " VideoDecodeDpbKHR |";
|
|
|
94 if ( value & FormatFeatureFlagBits::eAccelerationStructureVertexBufferKHR )
|
|
|
95 result += " AccelerationStructureVertexBufferKHR |";
|
|
|
96 if ( value & FormatFeatureFlagBits::eSampledImageFilterCubicEXT )
|
|
|
97 result += " SampledImageFilterCubicEXT |";
|
|
|
98 if ( value & FormatFeatureFlagBits::eFragmentDensityMapEXT )
|
|
|
99 result += " FragmentDensityMapEXT |";
|
|
|
100 if ( value & FormatFeatureFlagBits::eFragmentShadingRateAttachmentKHR )
|
|
|
101 result += " FragmentShadingRateAttachmentKHR |";
|
|
|
102 if ( value & FormatFeatureFlagBits::eVideoEncodeInputKHR )
|
|
|
103 result += " VideoEncodeInputKHR |";
|
|
|
104 if ( value & FormatFeatureFlagBits::eVideoEncodeDpbKHR )
|
|
|
105 result += " VideoEncodeDpbKHR |";
|
|
|
106
|
|
|
107 if ( result.size() > 1 )
|
|
|
108 result.back() = '}';
|
|
|
109 else
|
|
|
110 result = "{}";
|
|
|
111 return result;
|
|
|
112 }
|
|
|
113
|
|
|
114 VULKAN_HPP_INLINE std::string to_string( ImageCreateFlags value )
|
|
|
115 {
|
|
|
116 std::string result = "{";
|
|
|
117 if ( value & ImageCreateFlagBits::eSparseBinding )
|
|
|
118 result += " SparseBinding |";
|
|
|
119 if ( value & ImageCreateFlagBits::eSparseResidency )
|
|
|
120 result += " SparseResidency |";
|
|
|
121 if ( value & ImageCreateFlagBits::eSparseAliased )
|
|
|
122 result += " SparseAliased |";
|
|
|
123 if ( value & ImageCreateFlagBits::eMutableFormat )
|
|
|
124 result += " MutableFormat |";
|
|
|
125 if ( value & ImageCreateFlagBits::eCubeCompatible )
|
|
|
126 result += " CubeCompatible |";
|
|
|
127 if ( value & ImageCreateFlagBits::eAlias )
|
|
|
128 result += " Alias |";
|
|
|
129 if ( value & ImageCreateFlagBits::eSplitInstanceBindRegions )
|
|
|
130 result += " SplitInstanceBindRegions |";
|
|
|
131 if ( value & ImageCreateFlagBits::e2DArrayCompatible )
|
|
|
132 result += " 2DArrayCompatible |";
|
|
|
133 if ( value & ImageCreateFlagBits::eBlockTexelViewCompatible )
|
|
|
134 result += " BlockTexelViewCompatible |";
|
|
|
135 if ( value & ImageCreateFlagBits::eExtendedUsage )
|
|
|
136 result += " ExtendedUsage |";
|
|
|
137 if ( value & ImageCreateFlagBits::eProtected )
|
|
|
138 result += " Protected |";
|
|
|
139 if ( value & ImageCreateFlagBits::eDisjoint )
|
|
|
140 result += " Disjoint |";
|
|
|
141 if ( value & ImageCreateFlagBits::eCornerSampledNV )
|
|
|
142 result += " CornerSampledNV |";
|
|
|
143 if ( value & ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT )
|
|
|
144 result += " SampleLocationsCompatibleDepthEXT |";
|
|
|
145 if ( value & ImageCreateFlagBits::eSubsampledEXT )
|
|
|
146 result += " SubsampledEXT |";
|
|
|
147 if ( value & ImageCreateFlagBits::eDescriptorBufferCaptureReplayEXT )
|
|
|
148 result += " DescriptorBufferCaptureReplayEXT |";
|
|
|
149 if ( value & ImageCreateFlagBits::eMultisampledRenderToSingleSampledEXT )
|
|
|
150 result += " MultisampledRenderToSingleSampledEXT |";
|
|
|
151 if ( value & ImageCreateFlagBits::e2DViewCompatibleEXT )
|
|
|
152 result += " 2DViewCompatibleEXT |";
|
|
|
153 if ( value & ImageCreateFlagBits::eVideoProfileIndependentKHR )
|
|
|
154 result += " VideoProfileIndependentKHR |";
|
|
|
155 if ( value & ImageCreateFlagBits::eFragmentDensityMapOffsetEXT )
|
|
|
156 result += " FragmentDensityMapOffsetEXT |";
|
|
|
157
|
|
|
158 if ( result.size() > 1 )
|
|
|
159 result.back() = '}';
|
|
|
160 else
|
|
|
161 result = "{}";
|
|
|
162 return result;
|
|
|
163 }
|
|
|
164
|
|
|
165 VULKAN_HPP_INLINE std::string to_string( ImageUsageFlags value )
|
|
|
166 {
|
|
|
167 std::string result = "{";
|
|
|
168 if ( value & ImageUsageFlagBits::eTransferSrc )
|
|
|
169 result += " TransferSrc |";
|
|
|
170 if ( value & ImageUsageFlagBits::eTransferDst )
|
|
|
171 result += " TransferDst |";
|
|
|
172 if ( value & ImageUsageFlagBits::eSampled )
|
|
|
173 result += " Sampled |";
|
|
|
174 if ( value & ImageUsageFlagBits::eStorage )
|
|
|
175 result += " Storage |";
|
|
|
176 if ( value & ImageUsageFlagBits::eColorAttachment )
|
|
|
177 result += " ColorAttachment |";
|
|
|
178 if ( value & ImageUsageFlagBits::eDepthStencilAttachment )
|
|
|
179 result += " DepthStencilAttachment |";
|
|
|
180 if ( value & ImageUsageFlagBits::eTransientAttachment )
|
|
|
181 result += " TransientAttachment |";
|
|
|
182 if ( value & ImageUsageFlagBits::eInputAttachment )
|
|
|
183 result += " InputAttachment |";
|
|
|
184 if ( value & ImageUsageFlagBits::eHostTransfer )
|
|
|
185 result += " HostTransfer |";
|
|
|
186 if ( value & ImageUsageFlagBits::eVideoDecodeDstKHR )
|
|
|
187 result += " VideoDecodeDstKHR |";
|
|
|
188 if ( value & ImageUsageFlagBits::eVideoDecodeSrcKHR )
|
|
|
189 result += " VideoDecodeSrcKHR |";
|
|
|
190 if ( value & ImageUsageFlagBits::eVideoDecodeDpbKHR )
|
|
|
191 result += " VideoDecodeDpbKHR |";
|
|
|
192 if ( value & ImageUsageFlagBits::eFragmentDensityMapEXT )
|
|
|
193 result += " FragmentDensityMapEXT |";
|
|
|
194 if ( value & ImageUsageFlagBits::eFragmentShadingRateAttachmentKHR )
|
|
|
195 result += " FragmentShadingRateAttachmentKHR |";
|
|
|
196 if ( value & ImageUsageFlagBits::eVideoEncodeDstKHR )
|
|
|
197 result += " VideoEncodeDstKHR |";
|
|
|
198 if ( value & ImageUsageFlagBits::eVideoEncodeSrcKHR )
|
|
|
199 result += " VideoEncodeSrcKHR |";
|
|
|
200 if ( value & ImageUsageFlagBits::eVideoEncodeDpbKHR )
|
|
|
201 result += " VideoEncodeDpbKHR |";
|
|
|
202 if ( value & ImageUsageFlagBits::eAttachmentFeedbackLoopEXT )
|
|
|
203 result += " AttachmentFeedbackLoopEXT |";
|
|
|
204 if ( value & ImageUsageFlagBits::eInvocationMaskHUAWEI )
|
|
|
205 result += " InvocationMaskHUAWEI |";
|
|
|
206 if ( value & ImageUsageFlagBits::eSampleWeightQCOM )
|
|
|
207 result += " SampleWeightQCOM |";
|
|
|
208 if ( value & ImageUsageFlagBits::eSampleBlockMatchQCOM )
|
|
|
209 result += " SampleBlockMatchQCOM |";
|
|
|
210 if ( value & ImageUsageFlagBits::eTensorAliasingARM )
|
|
|
211 result += " TensorAliasingARM |";
|
|
|
212 if ( value & ImageUsageFlagBits::eTileMemoryQCOM )
|
|
|
213 result += " TileMemoryQCOM |";
|
|
|
214 if ( value & ImageUsageFlagBits::eVideoEncodeQuantizationDeltaMapKHR )
|
|
|
215 result += " VideoEncodeQuantizationDeltaMapKHR |";
|
|
|
216 if ( value & ImageUsageFlagBits::eVideoEncodeEmphasisMapKHR )
|
|
|
217 result += " VideoEncodeEmphasisMapKHR |";
|
|
|
218
|
|
|
219 if ( result.size() > 1 )
|
|
|
220 result.back() = '}';
|
|
|
221 else
|
|
|
222 result = "{}";
|
|
|
223 return result;
|
|
|
224 }
|
|
|
225
|
|
|
226 VULKAN_HPP_INLINE std::string to_string( InstanceCreateFlags value )
|
|
|
227 {
|
|
|
228 std::string result = "{";
|
|
|
229 if ( value & InstanceCreateFlagBits::eEnumeratePortabilityKHR )
|
|
|
230 result += " EnumeratePortabilityKHR |";
|
|
|
231
|
|
|
232 if ( result.size() > 1 )
|
|
|
233 result.back() = '}';
|
|
|
234 else
|
|
|
235 result = "{}";
|
|
|
236 return result;
|
|
|
237 }
|
|
|
238
|
|
|
239 VULKAN_HPP_INLINE std::string to_string( MemoryHeapFlags value )
|
|
|
240 {
|
|
|
241 std::string result = "{";
|
|
|
242 if ( value & MemoryHeapFlagBits::eDeviceLocal )
|
|
|
243 result += " DeviceLocal |";
|
|
|
244 if ( value & MemoryHeapFlagBits::eMultiInstance )
|
|
|
245 result += " MultiInstance |";
|
|
|
246 if ( value & MemoryHeapFlagBits::eTileMemoryQCOM )
|
|
|
247 result += " TileMemoryQCOM |";
|
|
|
248
|
|
|
249 if ( result.size() > 1 )
|
|
|
250 result.back() = '}';
|
|
|
251 else
|
|
|
252 result = "{}";
|
|
|
253 return result;
|
|
|
254 }
|
|
|
255
|
|
|
256 VULKAN_HPP_INLINE std::string to_string( MemoryPropertyFlags value )
|
|
|
257 {
|
|
|
258 std::string result = "{";
|
|
|
259 if ( value & MemoryPropertyFlagBits::eDeviceLocal )
|
|
|
260 result += " DeviceLocal |";
|
|
|
261 if ( value & MemoryPropertyFlagBits::eHostVisible )
|
|
|
262 result += " HostVisible |";
|
|
|
263 if ( value & MemoryPropertyFlagBits::eHostCoherent )
|
|
|
264 result += " HostCoherent |";
|
|
|
265 if ( value & MemoryPropertyFlagBits::eHostCached )
|
|
|
266 result += " HostCached |";
|
|
|
267 if ( value & MemoryPropertyFlagBits::eLazilyAllocated )
|
|
|
268 result += " LazilyAllocated |";
|
|
|
269 if ( value & MemoryPropertyFlagBits::eProtected )
|
|
|
270 result += " Protected |";
|
|
|
271 if ( value & MemoryPropertyFlagBits::eDeviceCoherentAMD )
|
|
|
272 result += " DeviceCoherentAMD |";
|
|
|
273 if ( value & MemoryPropertyFlagBits::eDeviceUncachedAMD )
|
|
|
274 result += " DeviceUncachedAMD |";
|
|
|
275 if ( value & MemoryPropertyFlagBits::eRdmaCapableNV )
|
|
|
276 result += " RdmaCapableNV |";
|
|
|
277
|
|
|
278 if ( result.size() > 1 )
|
|
|
279 result.back() = '}';
|
|
|
280 else
|
|
|
281 result = "{}";
|
|
|
282 return result;
|
|
|
283 }
|
|
|
284
|
|
|
285 VULKAN_HPP_INLINE std::string to_string( QueueFlags value )
|
|
|
286 {
|
|
|
287 std::string result = "{";
|
|
|
288 if ( value & QueueFlagBits::eGraphics )
|
|
|
289 result += " Graphics |";
|
|
|
290 if ( value & QueueFlagBits::eCompute )
|
|
|
291 result += " Compute |";
|
|
|
292 if ( value & QueueFlagBits::eTransfer )
|
|
|
293 result += " Transfer |";
|
|
|
294 if ( value & QueueFlagBits::eSparseBinding )
|
|
|
295 result += " SparseBinding |";
|
|
|
296 if ( value & QueueFlagBits::eProtected )
|
|
|
297 result += " Protected |";
|
|
|
298 if ( value & QueueFlagBits::eVideoDecodeKHR )
|
|
|
299 result += " VideoDecodeKHR |";
|
|
|
300 if ( value & QueueFlagBits::eVideoEncodeKHR )
|
|
|
301 result += " VideoEncodeKHR |";
|
|
|
302 if ( value & QueueFlagBits::eOpticalFlowNV )
|
|
|
303 result += " OpticalFlowNV |";
|
|
|
304 if ( value & QueueFlagBits::eDataGraphARM )
|
|
|
305 result += " DataGraphARM |";
|
|
|
306
|
|
|
307 if ( result.size() > 1 )
|
|
|
308 result.back() = '}';
|
|
|
309 else
|
|
|
310 result = "{}";
|
|
|
311 return result;
|
|
|
312 }
|
|
|
313
|
|
|
314 VULKAN_HPP_INLINE std::string to_string( SampleCountFlags value )
|
|
|
315 {
|
|
|
316 std::string result = "{";
|
|
|
317 if ( value & SampleCountFlagBits::e1 )
|
|
|
318 result += " 1 |";
|
|
|
319 if ( value & SampleCountFlagBits::e2 )
|
|
|
320 result += " 2 |";
|
|
|
321 if ( value & SampleCountFlagBits::e4 )
|
|
|
322 result += " 4 |";
|
|
|
323 if ( value & SampleCountFlagBits::e8 )
|
|
|
324 result += " 8 |";
|
|
|
325 if ( value & SampleCountFlagBits::e16 )
|
|
|
326 result += " 16 |";
|
|
|
327 if ( value & SampleCountFlagBits::e32 )
|
|
|
328 result += " 32 |";
|
|
|
329 if ( value & SampleCountFlagBits::e64 )
|
|
|
330 result += " 64 |";
|
|
|
331
|
|
|
332 if ( result.size() > 1 )
|
|
|
333 result.back() = '}';
|
|
|
334 else
|
|
|
335 result = "{}";
|
|
|
336 return result;
|
|
|
337 }
|
|
|
338
|
|
|
339 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceCreateFlags )
|
|
|
340 {
|
|
|
341 return "{}";
|
|
|
342 }
|
|
|
343
|
|
|
344 VULKAN_HPP_INLINE std::string to_string( DeviceQueueCreateFlags value )
|
|
|
345 {
|
|
|
346 std::string result = "{";
|
|
|
347 if ( value & DeviceQueueCreateFlagBits::eProtected )
|
|
|
348 result += " Protected |";
|
|
|
349
|
|
|
350 if ( result.size() > 1 )
|
|
|
351 result.back() = '}';
|
|
|
352 else
|
|
|
353 result = "{}";
|
|
|
354 return result;
|
|
|
355 }
|
|
|
356
|
|
|
357 VULKAN_HPP_INLINE std::string to_string( PipelineStageFlags value )
|
|
|
358 {
|
|
|
359 std::string result = "{";
|
|
|
360 if ( value & PipelineStageFlagBits::eTopOfPipe )
|
|
|
361 result += " TopOfPipe |";
|
|
|
362 if ( value & PipelineStageFlagBits::eDrawIndirect )
|
|
|
363 result += " DrawIndirect |";
|
|
|
364 if ( value & PipelineStageFlagBits::eVertexInput )
|
|
|
365 result += " VertexInput |";
|
|
|
366 if ( value & PipelineStageFlagBits::eVertexShader )
|
|
|
367 result += " VertexShader |";
|
|
|
368 if ( value & PipelineStageFlagBits::eTessellationControlShader )
|
|
|
369 result += " TessellationControlShader |";
|
|
|
370 if ( value & PipelineStageFlagBits::eTessellationEvaluationShader )
|
|
|
371 result += " TessellationEvaluationShader |";
|
|
|
372 if ( value & PipelineStageFlagBits::eGeometryShader )
|
|
|
373 result += " GeometryShader |";
|
|
|
374 if ( value & PipelineStageFlagBits::eFragmentShader )
|
|
|
375 result += " FragmentShader |";
|
|
|
376 if ( value & PipelineStageFlagBits::eEarlyFragmentTests )
|
|
|
377 result += " EarlyFragmentTests |";
|
|
|
378 if ( value & PipelineStageFlagBits::eLateFragmentTests )
|
|
|
379 result += " LateFragmentTests |";
|
|
|
380 if ( value & PipelineStageFlagBits::eColorAttachmentOutput )
|
|
|
381 result += " ColorAttachmentOutput |";
|
|
|
382 if ( value & PipelineStageFlagBits::eComputeShader )
|
|
|
383 result += " ComputeShader |";
|
|
|
384 if ( value & PipelineStageFlagBits::eTransfer )
|
|
|
385 result += " Transfer |";
|
|
|
386 if ( value & PipelineStageFlagBits::eBottomOfPipe )
|
|
|
387 result += " BottomOfPipe |";
|
|
|
388 if ( value & PipelineStageFlagBits::eHost )
|
|
|
389 result += " Host |";
|
|
|
390 if ( value & PipelineStageFlagBits::eAllGraphics )
|
|
|
391 result += " AllGraphics |";
|
|
|
392 if ( value & PipelineStageFlagBits::eAllCommands )
|
|
|
393 result += " AllCommands |";
|
|
|
394 if ( value & PipelineStageFlagBits::eTransformFeedbackEXT )
|
|
|
395 result += " TransformFeedbackEXT |";
|
|
|
396 if ( value & PipelineStageFlagBits::eConditionalRenderingEXT )
|
|
|
397 result += " ConditionalRenderingEXT |";
|
|
|
398 if ( value & PipelineStageFlagBits::eAccelerationStructureBuildKHR )
|
|
|
399 result += " AccelerationStructureBuildKHR |";
|
|
|
400 if ( value & PipelineStageFlagBits::eRayTracingShaderKHR )
|
|
|
401 result += " RayTracingShaderKHR |";
|
|
|
402 if ( value & PipelineStageFlagBits::eFragmentDensityProcessEXT )
|
|
|
403 result += " FragmentDensityProcessEXT |";
|
|
|
404 if ( value & PipelineStageFlagBits::eFragmentShadingRateAttachmentKHR )
|
|
|
405 result += " FragmentShadingRateAttachmentKHR |";
|
|
|
406 if ( value & PipelineStageFlagBits::eTaskShaderEXT )
|
|
|
407 result += " TaskShaderEXT |";
|
|
|
408 if ( value & PipelineStageFlagBits::eMeshShaderEXT )
|
|
|
409 result += " MeshShaderEXT |";
|
|
|
410 if ( value & PipelineStageFlagBits::eCommandPreprocessEXT )
|
|
|
411 result += " CommandPreprocessEXT |";
|
|
|
412
|
|
|
413 if ( result.size() > 1 )
|
|
|
414 result.back() = '}';
|
|
|
415 else
|
|
|
416 result = "None";
|
|
|
417 return result;
|
|
|
418 }
|
|
|
419
|
|
|
420 VULKAN_HPP_INLINE std::string to_string( MemoryMapFlags value )
|
|
|
421 {
|
|
|
422 std::string result = "{";
|
|
|
423 if ( value & MemoryMapFlagBits::ePlacedEXT )
|
|
|
424 result += " PlacedEXT |";
|
|
|
425
|
|
|
426 if ( result.size() > 1 )
|
|
|
427 result.back() = '}';
|
|
|
428 else
|
|
|
429 result = "{}";
|
|
|
430 return result;
|
|
|
431 }
|
|
|
432
|
|
|
433 VULKAN_HPP_INLINE std::string to_string( ImageAspectFlags value )
|
|
|
434 {
|
|
|
435 std::string result = "{";
|
|
|
436 if ( value & ImageAspectFlagBits::eColor )
|
|
|
437 result += " Color |";
|
|
|
438 if ( value & ImageAspectFlagBits::eDepth )
|
|
|
439 result += " Depth |";
|
|
|
440 if ( value & ImageAspectFlagBits::eStencil )
|
|
|
441 result += " Stencil |";
|
|
|
442 if ( value & ImageAspectFlagBits::eMetadata )
|
|
|
443 result += " Metadata |";
|
|
|
444 if ( value & ImageAspectFlagBits::ePlane0 )
|
|
|
445 result += " Plane0 |";
|
|
|
446 if ( value & ImageAspectFlagBits::ePlane1 )
|
|
|
447 result += " Plane1 |";
|
|
|
448 if ( value & ImageAspectFlagBits::ePlane2 )
|
|
|
449 result += " Plane2 |";
|
|
|
450 if ( value & ImageAspectFlagBits::eMemoryPlane0EXT )
|
|
|
451 result += " MemoryPlane0EXT |";
|
|
|
452 if ( value & ImageAspectFlagBits::eMemoryPlane1EXT )
|
|
|
453 result += " MemoryPlane1EXT |";
|
|
|
454 if ( value & ImageAspectFlagBits::eMemoryPlane2EXT )
|
|
|
455 result += " MemoryPlane2EXT |";
|
|
|
456 if ( value & ImageAspectFlagBits::eMemoryPlane3EXT )
|
|
|
457 result += " MemoryPlane3EXT |";
|
|
|
458
|
|
|
459 if ( result.size() > 1 )
|
|
|
460 result.back() = '}';
|
|
|
461 else
|
|
|
462 result = "None";
|
|
|
463 return result;
|
|
|
464 }
|
|
|
465
|
|
|
466 VULKAN_HPP_INLINE std::string to_string( SparseImageFormatFlags value )
|
|
|
467 {
|
|
|
468 std::string result = "{";
|
|
|
469 if ( value & SparseImageFormatFlagBits::eSingleMiptail )
|
|
|
470 result += " SingleMiptail |";
|
|
|
471 if ( value & SparseImageFormatFlagBits::eAlignedMipSize )
|
|
|
472 result += " AlignedMipSize |";
|
|
|
473 if ( value & SparseImageFormatFlagBits::eNonstandardBlockSize )
|
|
|
474 result += " NonstandardBlockSize |";
|
|
|
475
|
|
|
476 if ( result.size() > 1 )
|
|
|
477 result.back() = '}';
|
|
|
478 else
|
|
|
479 result = "{}";
|
|
|
480 return result;
|
|
|
481 }
|
|
|
482
|
|
|
483 VULKAN_HPP_INLINE std::string to_string( SparseMemoryBindFlags value )
|
|
|
484 {
|
|
|
485 std::string result = "{";
|
|
|
486 if ( value & SparseMemoryBindFlagBits::eMetadata )
|
|
|
487 result += " Metadata |";
|
|
|
488
|
|
|
489 if ( result.size() > 1 )
|
|
|
490 result.back() = '}';
|
|
|
491 else
|
|
|
492 result = "{}";
|
|
|
493 return result;
|
|
|
494 }
|
|
|
495
|
|
|
496 VULKAN_HPP_INLINE std::string to_string( FenceCreateFlags value )
|
|
|
497 {
|
|
|
498 std::string result = "{";
|
|
|
499 if ( value & FenceCreateFlagBits::eSignaled )
|
|
|
500 result += " Signaled |";
|
|
|
501
|
|
|
502 if ( result.size() > 1 )
|
|
|
503 result.back() = '}';
|
|
|
504 else
|
|
|
505 result = "{}";
|
|
|
506 return result;
|
|
|
507 }
|
|
|
508
|
|
|
509 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SemaphoreCreateFlags )
|
|
|
510 {
|
|
|
511 return "{}";
|
|
|
512 }
|
|
|
513
|
|
|
514 VULKAN_HPP_INLINE std::string to_string( QueryPoolCreateFlags value )
|
|
|
515 {
|
|
|
516 std::string result = "{";
|
|
|
517 if ( value & QueryPoolCreateFlagBits::eResetKHR )
|
|
|
518 result += " ResetKHR |";
|
|
|
519
|
|
|
520 if ( result.size() > 1 )
|
|
|
521 result.back() = '}';
|
|
|
522 else
|
|
|
523 result = "{}";
|
|
|
524 return result;
|
|
|
525 }
|
|
|
526
|
|
|
527 VULKAN_HPP_INLINE std::string to_string( QueryResultFlags value )
|
|
|
528 {
|
|
|
529 std::string result = "{";
|
|
|
530 if ( value & QueryResultFlagBits::e64 )
|
|
|
531 result += " 64 |";
|
|
|
532 if ( value & QueryResultFlagBits::eWait )
|
|
|
533 result += " Wait |";
|
|
|
534 if ( value & QueryResultFlagBits::eWithAvailability )
|
|
|
535 result += " WithAvailability |";
|
|
|
536 if ( value & QueryResultFlagBits::ePartial )
|
|
|
537 result += " Partial |";
|
|
|
538 if ( value & QueryResultFlagBits::eWithStatusKHR )
|
|
|
539 result += " WithStatusKHR |";
|
|
|
540
|
|
|
541 if ( result.size() > 1 )
|
|
|
542 result.back() = '}';
|
|
|
543 else
|
|
|
544 result = "{}";
|
|
|
545 return result;
|
|
|
546 }
|
|
|
547
|
|
|
548 VULKAN_HPP_INLINE std::string to_string( BufferCreateFlags value )
|
|
|
549 {
|
|
|
550 std::string result = "{";
|
|
|
551 if ( value & BufferCreateFlagBits::eSparseBinding )
|
|
|
552 result += " SparseBinding |";
|
|
|
553 if ( value & BufferCreateFlagBits::eSparseResidency )
|
|
|
554 result += " SparseResidency |";
|
|
|
555 if ( value & BufferCreateFlagBits::eSparseAliased )
|
|
|
556 result += " SparseAliased |";
|
|
|
557 if ( value & BufferCreateFlagBits::eProtected )
|
|
|
558 result += " Protected |";
|
|
|
559 if ( value & BufferCreateFlagBits::eDeviceAddressCaptureReplay )
|
|
|
560 result += " DeviceAddressCaptureReplay |";
|
|
|
561 if ( value & BufferCreateFlagBits::eDescriptorBufferCaptureReplayEXT )
|
|
|
562 result += " DescriptorBufferCaptureReplayEXT |";
|
|
|
563 if ( value & BufferCreateFlagBits::eVideoProfileIndependentKHR )
|
|
|
564 result += " VideoProfileIndependentKHR |";
|
|
|
565
|
|
|
566 if ( result.size() > 1 )
|
|
|
567 result.back() = '}';
|
|
|
568 else
|
|
|
569 result = "{}";
|
|
|
570 return result;
|
|
|
571 }
|
|
|
572
|
|
|
573 VULKAN_HPP_INLINE std::string to_string( BufferUsageFlags value )
|
|
|
574 {
|
|
|
575 std::string result = "{";
|
|
|
576 if ( value & BufferUsageFlagBits::eTransferSrc )
|
|
|
577 result += " TransferSrc |";
|
|
|
578 if ( value & BufferUsageFlagBits::eTransferDst )
|
|
|
579 result += " TransferDst |";
|
|
|
580 if ( value & BufferUsageFlagBits::eUniformTexelBuffer )
|
|
|
581 result += " UniformTexelBuffer |";
|
|
|
582 if ( value & BufferUsageFlagBits::eStorageTexelBuffer )
|
|
|
583 result += " StorageTexelBuffer |";
|
|
|
584 if ( value & BufferUsageFlagBits::eUniformBuffer )
|
|
|
585 result += " UniformBuffer |";
|
|
|
586 if ( value & BufferUsageFlagBits::eStorageBuffer )
|
|
|
587 result += " StorageBuffer |";
|
|
|
588 if ( value & BufferUsageFlagBits::eIndexBuffer )
|
|
|
589 result += " IndexBuffer |";
|
|
|
590 if ( value & BufferUsageFlagBits::eVertexBuffer )
|
|
|
591 result += " VertexBuffer |";
|
|
|
592 if ( value & BufferUsageFlagBits::eIndirectBuffer )
|
|
|
593 result += " IndirectBuffer |";
|
|
|
594 if ( value & BufferUsageFlagBits::eShaderDeviceAddress )
|
|
|
595 result += " ShaderDeviceAddress |";
|
|
|
596 if ( value & BufferUsageFlagBits::eVideoDecodeSrcKHR )
|
|
|
597 result += " VideoDecodeSrcKHR |";
|
|
|
598 if ( value & BufferUsageFlagBits::eVideoDecodeDstKHR )
|
|
|
599 result += " VideoDecodeDstKHR |";
|
|
|
600 if ( value & BufferUsageFlagBits::eTransformFeedbackBufferEXT )
|
|
|
601 result += " TransformFeedbackBufferEXT |";
|
|
|
602 if ( value & BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT )
|
|
|
603 result += " TransformFeedbackCounterBufferEXT |";
|
|
|
604 if ( value & BufferUsageFlagBits::eConditionalRenderingEXT )
|
|
|
605 result += " ConditionalRenderingEXT |";
|
|
|
606 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
607 if ( value & BufferUsageFlagBits::eExecutionGraphScratchAMDX )
|
|
|
608 result += " ExecutionGraphScratchAMDX |";
|
|
|
609 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
610 if ( value & BufferUsageFlagBits::eAccelerationStructureBuildInputReadOnlyKHR )
|
|
|
611 result += " AccelerationStructureBuildInputReadOnlyKHR |";
|
|
|
612 if ( value & BufferUsageFlagBits::eAccelerationStructureStorageKHR )
|
|
|
613 result += " AccelerationStructureStorageKHR |";
|
|
|
614 if ( value & BufferUsageFlagBits::eShaderBindingTableKHR )
|
|
|
615 result += " ShaderBindingTableKHR |";
|
|
|
616 if ( value & BufferUsageFlagBits::eVideoEncodeDstKHR )
|
|
|
617 result += " VideoEncodeDstKHR |";
|
|
|
618 if ( value & BufferUsageFlagBits::eVideoEncodeSrcKHR )
|
|
|
619 result += " VideoEncodeSrcKHR |";
|
|
|
620 if ( value & BufferUsageFlagBits::eSamplerDescriptorBufferEXT )
|
|
|
621 result += " SamplerDescriptorBufferEXT |";
|
|
|
622 if ( value & BufferUsageFlagBits::eResourceDescriptorBufferEXT )
|
|
|
623 result += " ResourceDescriptorBufferEXT |";
|
|
|
624 if ( value & BufferUsageFlagBits::ePushDescriptorsDescriptorBufferEXT )
|
|
|
625 result += " PushDescriptorsDescriptorBufferEXT |";
|
|
|
626 if ( value & BufferUsageFlagBits::eMicromapBuildInputReadOnlyEXT )
|
|
|
627 result += " MicromapBuildInputReadOnlyEXT |";
|
|
|
628 if ( value & BufferUsageFlagBits::eMicromapStorageEXT )
|
|
|
629 result += " MicromapStorageEXT |";
|
|
|
630 if ( value & BufferUsageFlagBits::eTileMemoryQCOM )
|
|
|
631 result += " TileMemoryQCOM |";
|
|
|
632
|
|
|
633 if ( result.size() > 1 )
|
|
|
634 result.back() = '}';
|
|
|
635 else
|
|
|
636 result = "{}";
|
|
|
637 return result;
|
|
|
638 }
|
|
|
639
|
|
|
640 VULKAN_HPP_INLINE std::string to_string( ImageViewCreateFlags value )
|
|
|
641 {
|
|
|
642 std::string result = "{";
|
|
|
643 if ( value & ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT )
|
|
|
644 result += " FragmentDensityMapDynamicEXT |";
|
|
|
645 if ( value & ImageViewCreateFlagBits::eDescriptorBufferCaptureReplayEXT )
|
|
|
646 result += " DescriptorBufferCaptureReplayEXT |";
|
|
|
647 if ( value & ImageViewCreateFlagBits::eFragmentDensityMapDeferredEXT )
|
|
|
648 result += " FragmentDensityMapDeferredEXT |";
|
|
|
649
|
|
|
650 if ( result.size() > 1 )
|
|
|
651 result.back() = '}';
|
|
|
652 else
|
|
|
653 result = "{}";
|
|
|
654 return result;
|
|
|
655 }
|
|
|
656
|
|
|
657 VULKAN_HPP_INLINE std::string to_string( AccessFlags value )
|
|
|
658 {
|
|
|
659 std::string result = "{";
|
|
|
660 if ( value & AccessFlagBits::eIndirectCommandRead )
|
|
|
661 result += " IndirectCommandRead |";
|
|
|
662 if ( value & AccessFlagBits::eIndexRead )
|
|
|
663 result += " IndexRead |";
|
|
|
664 if ( value & AccessFlagBits::eVertexAttributeRead )
|
|
|
665 result += " VertexAttributeRead |";
|
|
|
666 if ( value & AccessFlagBits::eUniformRead )
|
|
|
667 result += " UniformRead |";
|
|
|
668 if ( value & AccessFlagBits::eInputAttachmentRead )
|
|
|
669 result += " InputAttachmentRead |";
|
|
|
670 if ( value & AccessFlagBits::eShaderRead )
|
|
|
671 result += " ShaderRead |";
|
|
|
672 if ( value & AccessFlagBits::eShaderWrite )
|
|
|
673 result += " ShaderWrite |";
|
|
|
674 if ( value & AccessFlagBits::eColorAttachmentRead )
|
|
|
675 result += " ColorAttachmentRead |";
|
|
|
676 if ( value & AccessFlagBits::eColorAttachmentWrite )
|
|
|
677 result += " ColorAttachmentWrite |";
|
|
|
678 if ( value & AccessFlagBits::eDepthStencilAttachmentRead )
|
|
|
679 result += " DepthStencilAttachmentRead |";
|
|
|
680 if ( value & AccessFlagBits::eDepthStencilAttachmentWrite )
|
|
|
681 result += " DepthStencilAttachmentWrite |";
|
|
|
682 if ( value & AccessFlagBits::eTransferRead )
|
|
|
683 result += " TransferRead |";
|
|
|
684 if ( value & AccessFlagBits::eTransferWrite )
|
|
|
685 result += " TransferWrite |";
|
|
|
686 if ( value & AccessFlagBits::eHostRead )
|
|
|
687 result += " HostRead |";
|
|
|
688 if ( value & AccessFlagBits::eHostWrite )
|
|
|
689 result += " HostWrite |";
|
|
|
690 if ( value & AccessFlagBits::eMemoryRead )
|
|
|
691 result += " MemoryRead |";
|
|
|
692 if ( value & AccessFlagBits::eMemoryWrite )
|
|
|
693 result += " MemoryWrite |";
|
|
|
694 if ( value & AccessFlagBits::eTransformFeedbackWriteEXT )
|
|
|
695 result += " TransformFeedbackWriteEXT |";
|
|
|
696 if ( value & AccessFlagBits::eTransformFeedbackCounterReadEXT )
|
|
|
697 result += " TransformFeedbackCounterReadEXT |";
|
|
|
698 if ( value & AccessFlagBits::eTransformFeedbackCounterWriteEXT )
|
|
|
699 result += " TransformFeedbackCounterWriteEXT |";
|
|
|
700 if ( value & AccessFlagBits::eConditionalRenderingReadEXT )
|
|
|
701 result += " ConditionalRenderingReadEXT |";
|
|
|
702 if ( value & AccessFlagBits::eColorAttachmentReadNoncoherentEXT )
|
|
|
703 result += " ColorAttachmentReadNoncoherentEXT |";
|
|
|
704 if ( value & AccessFlagBits::eAccelerationStructureReadKHR )
|
|
|
705 result += " AccelerationStructureReadKHR |";
|
|
|
706 if ( value & AccessFlagBits::eAccelerationStructureWriteKHR )
|
|
|
707 result += " AccelerationStructureWriteKHR |";
|
|
|
708 if ( value & AccessFlagBits::eFragmentDensityMapReadEXT )
|
|
|
709 result += " FragmentDensityMapReadEXT |";
|
|
|
710 if ( value & AccessFlagBits::eFragmentShadingRateAttachmentReadKHR )
|
|
|
711 result += " FragmentShadingRateAttachmentReadKHR |";
|
|
|
712 if ( value & AccessFlagBits::eCommandPreprocessReadEXT )
|
|
|
713 result += " CommandPreprocessReadEXT |";
|
|
|
714 if ( value & AccessFlagBits::eCommandPreprocessWriteEXT )
|
|
|
715 result += " CommandPreprocessWriteEXT |";
|
|
|
716
|
|
|
717 if ( result.size() > 1 )
|
|
|
718 result.back() = '}';
|
|
|
719 else
|
|
|
720 result = "None";
|
|
|
721 return result;
|
|
|
722 }
|
|
|
723
|
|
|
724 VULKAN_HPP_INLINE std::string to_string( DependencyFlags value )
|
|
|
725 {
|
|
|
726 std::string result = "{";
|
|
|
727 if ( value & DependencyFlagBits::eByRegion )
|
|
|
728 result += " ByRegion |";
|
|
|
729 if ( value & DependencyFlagBits::eDeviceGroup )
|
|
|
730 result += " DeviceGroup |";
|
|
|
731 if ( value & DependencyFlagBits::eViewLocal )
|
|
|
732 result += " ViewLocal |";
|
|
|
733 if ( value & DependencyFlagBits::eFeedbackLoopEXT )
|
|
|
734 result += " FeedbackLoopEXT |";
|
|
|
735 if ( value & DependencyFlagBits::eQueueFamilyOwnershipTransferUseAllStagesKHR )
|
|
|
736 result += " QueueFamilyOwnershipTransferUseAllStagesKHR |";
|
|
|
737 if ( value & DependencyFlagBits::eAsymmetricEventKHR )
|
|
|
738 result += " AsymmetricEventKHR |";
|
|
|
739
|
|
|
740 if ( result.size() > 1 )
|
|
|
741 result.back() = '}';
|
|
|
742 else
|
|
|
743 result = "{}";
|
|
|
744 return result;
|
|
|
745 }
|
|
|
746
|
|
|
747 VULKAN_HPP_INLINE std::string to_string( CommandPoolCreateFlags value )
|
|
|
748 {
|
|
|
749 std::string result = "{";
|
|
|
750 if ( value & CommandPoolCreateFlagBits::eTransient )
|
|
|
751 result += " Transient |";
|
|
|
752 if ( value & CommandPoolCreateFlagBits::eResetCommandBuffer )
|
|
|
753 result += " ResetCommandBuffer |";
|
|
|
754 if ( value & CommandPoolCreateFlagBits::eProtected )
|
|
|
755 result += " Protected |";
|
|
|
756
|
|
|
757 if ( result.size() > 1 )
|
|
|
758 result.back() = '}';
|
|
|
759 else
|
|
|
760 result = "{}";
|
|
|
761 return result;
|
|
|
762 }
|
|
|
763
|
|
|
764 VULKAN_HPP_INLINE std::string to_string( CommandPoolResetFlags value )
|
|
|
765 {
|
|
|
766 std::string result = "{";
|
|
|
767 if ( value & CommandPoolResetFlagBits::eReleaseResources )
|
|
|
768 result += " ReleaseResources |";
|
|
|
769
|
|
|
770 if ( result.size() > 1 )
|
|
|
771 result.back() = '}';
|
|
|
772 else
|
|
|
773 result = "{}";
|
|
|
774 return result;
|
|
|
775 }
|
|
|
776
|
|
|
777 VULKAN_HPP_INLINE std::string to_string( CommandBufferResetFlags value )
|
|
|
778 {
|
|
|
779 std::string result = "{";
|
|
|
780 if ( value & CommandBufferResetFlagBits::eReleaseResources )
|
|
|
781 result += " ReleaseResources |";
|
|
|
782
|
|
|
783 if ( result.size() > 1 )
|
|
|
784 result.back() = '}';
|
|
|
785 else
|
|
|
786 result = "{}";
|
|
|
787 return result;
|
|
|
788 }
|
|
|
789
|
|
|
790 VULKAN_HPP_INLINE std::string to_string( CommandBufferUsageFlags value )
|
|
|
791 {
|
|
|
792 std::string result = "{";
|
|
|
793 if ( value & CommandBufferUsageFlagBits::eOneTimeSubmit )
|
|
|
794 result += " OneTimeSubmit |";
|
|
|
795 if ( value & CommandBufferUsageFlagBits::eRenderPassContinue )
|
|
|
796 result += " RenderPassContinue |";
|
|
|
797 if ( value & CommandBufferUsageFlagBits::eSimultaneousUse )
|
|
|
798 result += " SimultaneousUse |";
|
|
|
799
|
|
|
800 if ( result.size() > 1 )
|
|
|
801 result.back() = '}';
|
|
|
802 else
|
|
|
803 result = "{}";
|
|
|
804 return result;
|
|
|
805 }
|
|
|
806
|
|
|
807 VULKAN_HPP_INLINE std::string to_string( QueryControlFlags value )
|
|
|
808 {
|
|
|
809 std::string result = "{";
|
|
|
810 if ( value & QueryControlFlagBits::ePrecise )
|
|
|
811 result += " Precise |";
|
|
|
812
|
|
|
813 if ( result.size() > 1 )
|
|
|
814 result.back() = '}';
|
|
|
815 else
|
|
|
816 result = "{}";
|
|
|
817 return result;
|
|
|
818 }
|
|
|
819
|
|
|
820 VULKAN_HPP_INLINE std::string to_string( EventCreateFlags value )
|
|
|
821 {
|
|
|
822 std::string result = "{";
|
|
|
823 if ( value & EventCreateFlagBits::eDeviceOnly )
|
|
|
824 result += " DeviceOnly |";
|
|
|
825
|
|
|
826 if ( result.size() > 1 )
|
|
|
827 result.back() = '}';
|
|
|
828 else
|
|
|
829 result = "{}";
|
|
|
830 return result;
|
|
|
831 }
|
|
|
832
|
|
|
833 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BufferViewCreateFlags )
|
|
|
834 {
|
|
|
835 return "{}";
|
|
|
836 }
|
|
|
837
|
|
|
838 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderModuleCreateFlags )
|
|
|
839 {
|
|
|
840 return "{}";
|
|
|
841 }
|
|
|
842
|
|
|
843 VULKAN_HPP_INLINE std::string to_string( PipelineCacheCreateFlags value )
|
|
|
844 {
|
|
|
845 std::string result = "{";
|
|
|
846 if ( value & PipelineCacheCreateFlagBits::eExternallySynchronized )
|
|
|
847 result += " ExternallySynchronized |";
|
|
|
848 if ( value & PipelineCacheCreateFlagBits::eInternallySynchronizedMergeKHR )
|
|
|
849 result += " InternallySynchronizedMergeKHR |";
|
|
|
850
|
|
|
851 if ( result.size() > 1 )
|
|
|
852 result.back() = '}';
|
|
|
853 else
|
|
|
854 result = "{}";
|
|
|
855 return result;
|
|
|
856 }
|
|
|
857
|
|
|
858 VULKAN_HPP_INLINE std::string to_string( PipelineCreateFlags value )
|
|
|
859 {
|
|
|
860 std::string result = "{";
|
|
|
861 if ( value & PipelineCreateFlagBits::eDisableOptimization )
|
|
|
862 result += " DisableOptimization |";
|
|
|
863 if ( value & PipelineCreateFlagBits::eAllowDerivatives )
|
|
|
864 result += " AllowDerivatives |";
|
|
|
865 if ( value & PipelineCreateFlagBits::eDerivative )
|
|
|
866 result += " Derivative |";
|
|
|
867 if ( value & PipelineCreateFlagBits::eDispatchBase )
|
|
|
868 result += " DispatchBase |";
|
|
|
869 if ( value & PipelineCreateFlagBits::eViewIndexFromDeviceIndex )
|
|
|
870 result += " ViewIndexFromDeviceIndex |";
|
|
|
871 if ( value & PipelineCreateFlagBits::eFailOnPipelineCompileRequired )
|
|
|
872 result += " FailOnPipelineCompileRequired |";
|
|
|
873 if ( value & PipelineCreateFlagBits::eEarlyReturnOnFailure )
|
|
|
874 result += " EarlyReturnOnFailure |";
|
|
|
875 if ( value & PipelineCreateFlagBits::eNoProtectedAccess )
|
|
|
876 result += " NoProtectedAccess |";
|
|
|
877 if ( value & PipelineCreateFlagBits::eProtectedAccessOnly )
|
|
|
878 result += " ProtectedAccessOnly |";
|
|
|
879 if ( value & PipelineCreateFlagBits::eRayTracingNoNullAnyHitShadersKHR )
|
|
|
880 result += " RayTracingNoNullAnyHitShadersKHR |";
|
|
|
881 if ( value & PipelineCreateFlagBits::eRayTracingNoNullClosestHitShadersKHR )
|
|
|
882 result += " RayTracingNoNullClosestHitShadersKHR |";
|
|
|
883 if ( value & PipelineCreateFlagBits::eRayTracingNoNullMissShadersKHR )
|
|
|
884 result += " RayTracingNoNullMissShadersKHR |";
|
|
|
885 if ( value & PipelineCreateFlagBits::eRayTracingNoNullIntersectionShadersKHR )
|
|
|
886 result += " RayTracingNoNullIntersectionShadersKHR |";
|
|
|
887 if ( value & PipelineCreateFlagBits::eRayTracingSkipTrianglesKHR )
|
|
|
888 result += " RayTracingSkipTrianglesKHR |";
|
|
|
889 if ( value & PipelineCreateFlagBits::eRayTracingSkipAabbsKHR )
|
|
|
890 result += " RayTracingSkipAabbsKHR |";
|
|
|
891 if ( value & PipelineCreateFlagBits::eRayTracingShaderGroupHandleCaptureReplayKHR )
|
|
|
892 result += " RayTracingShaderGroupHandleCaptureReplayKHR |";
|
|
|
893 if ( value & PipelineCreateFlagBits::eDeferCompileNV )
|
|
|
894 result += " DeferCompileNV |";
|
|
|
895 if ( value & PipelineCreateFlagBits::eRenderingFragmentDensityMapAttachmentEXT )
|
|
|
896 result += " RenderingFragmentDensityMapAttachmentEXT |";
|
|
|
897 if ( value & PipelineCreateFlagBits::eRenderingFragmentShadingRateAttachmentKHR )
|
|
|
898 result += " RenderingFragmentShadingRateAttachmentKHR |";
|
|
|
899 if ( value & PipelineCreateFlagBits::eCaptureStatisticsKHR )
|
|
|
900 result += " CaptureStatisticsKHR |";
|
|
|
901 if ( value & PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR )
|
|
|
902 result += " CaptureInternalRepresentationsKHR |";
|
|
|
903 if ( value & PipelineCreateFlagBits::eIndirectBindableNV )
|
|
|
904 result += " IndirectBindableNV |";
|
|
|
905 if ( value & PipelineCreateFlagBits::eLibraryKHR )
|
|
|
906 result += " LibraryKHR |";
|
|
|
907 if ( value & PipelineCreateFlagBits::eDescriptorBufferEXT )
|
|
|
908 result += " DescriptorBufferEXT |";
|
|
|
909 if ( value & PipelineCreateFlagBits::eRetainLinkTimeOptimizationInfoEXT )
|
|
|
910 result += " RetainLinkTimeOptimizationInfoEXT |";
|
|
|
911 if ( value & PipelineCreateFlagBits::eLinkTimeOptimizationEXT )
|
|
|
912 result += " LinkTimeOptimizationEXT |";
|
|
|
913 if ( value & PipelineCreateFlagBits::eRayTracingAllowMotionNV )
|
|
|
914 result += " RayTracingAllowMotionNV |";
|
|
|
915 if ( value & PipelineCreateFlagBits::eColorAttachmentFeedbackLoopEXT )
|
|
|
916 result += " ColorAttachmentFeedbackLoopEXT |";
|
|
|
917 if ( value & PipelineCreateFlagBits::eDepthStencilAttachmentFeedbackLoopEXT )
|
|
|
918 result += " DepthStencilAttachmentFeedbackLoopEXT |";
|
|
|
919 if ( value & PipelineCreateFlagBits::eRayTracingOpacityMicromapEXT )
|
|
|
920 result += " RayTracingOpacityMicromapEXT |";
|
|
|
921 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
922 if ( value & PipelineCreateFlagBits::eRayTracingDisplacementMicromapNV )
|
|
|
923 result += " RayTracingDisplacementMicromapNV |";
|
|
|
924 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
925
|
|
|
926 if ( result.size() > 1 )
|
|
|
927 result.back() = '}';
|
|
|
928 else
|
|
|
929 result = "{}";
|
|
|
930 return result;
|
|
|
931 }
|
|
|
932
|
|
|
933 VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlags value )
|
|
|
934 {
|
|
|
935 std::string result = "{";
|
|
|
936 if ( value & PipelineLayoutCreateFlagBits::eIndependentSetsEXT )
|
|
|
937 result += " IndependentSetsEXT |";
|
|
|
938
|
|
|
939 if ( result.size() > 1 )
|
|
|
940 result.back() = '}';
|
|
|
941 else
|
|
|
942 result = "{}";
|
|
|
943 return result;
|
|
|
944 }
|
|
|
945
|
|
|
946 VULKAN_HPP_INLINE std::string to_string( PipelineShaderStageCreateFlags value )
|
|
|
947 {
|
|
|
948 std::string result = "{";
|
|
|
949 if ( value & PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSize )
|
|
|
950 result += " AllowVaryingSubgroupSize |";
|
|
|
951 if ( value & PipelineShaderStageCreateFlagBits::eRequireFullSubgroups )
|
|
|
952 result += " RequireFullSubgroups |";
|
|
|
953
|
|
|
954 if ( result.size() > 1 )
|
|
|
955 result.back() = '}';
|
|
|
956 else
|
|
|
957 result = "{}";
|
|
|
958 return result;
|
|
|
959 }
|
|
|
960
|
|
|
961 VULKAN_HPP_INLINE std::string to_string( ShaderStageFlags value )
|
|
|
962 {
|
|
|
963 std::string result = "{";
|
|
|
964 if ( value & ShaderStageFlagBits::eVertex )
|
|
|
965 result += " Vertex |";
|
|
|
966 if ( value & ShaderStageFlagBits::eTessellationControl )
|
|
|
967 result += " TessellationControl |";
|
|
|
968 if ( value & ShaderStageFlagBits::eTessellationEvaluation )
|
|
|
969 result += " TessellationEvaluation |";
|
|
|
970 if ( value & ShaderStageFlagBits::eGeometry )
|
|
|
971 result += " Geometry |";
|
|
|
972 if ( value & ShaderStageFlagBits::eFragment )
|
|
|
973 result += " Fragment |";
|
|
|
974 if ( value & ShaderStageFlagBits::eCompute )
|
|
|
975 result += " Compute |";
|
|
|
976 if ( value & ShaderStageFlagBits::eRaygenKHR )
|
|
|
977 result += " RaygenKHR |";
|
|
|
978 if ( value & ShaderStageFlagBits::eAnyHitKHR )
|
|
|
979 result += " AnyHitKHR |";
|
|
|
980 if ( value & ShaderStageFlagBits::eClosestHitKHR )
|
|
|
981 result += " ClosestHitKHR |";
|
|
|
982 if ( value & ShaderStageFlagBits::eMissKHR )
|
|
|
983 result += " MissKHR |";
|
|
|
984 if ( value & ShaderStageFlagBits::eIntersectionKHR )
|
|
|
985 result += " IntersectionKHR |";
|
|
|
986 if ( value & ShaderStageFlagBits::eCallableKHR )
|
|
|
987 result += " CallableKHR |";
|
|
|
988 if ( value & ShaderStageFlagBits::eTaskEXT )
|
|
|
989 result += " TaskEXT |";
|
|
|
990 if ( value & ShaderStageFlagBits::eMeshEXT )
|
|
|
991 result += " MeshEXT |";
|
|
|
992 if ( value & ShaderStageFlagBits::eSubpassShadingHUAWEI )
|
|
|
993 result += " SubpassShadingHUAWEI |";
|
|
|
994 if ( value & ShaderStageFlagBits::eClusterCullingHUAWEI )
|
|
|
995 result += " ClusterCullingHUAWEI |";
|
|
|
996
|
|
|
997 if ( result.size() > 1 )
|
|
|
998 result.back() = '}';
|
|
|
999 else
|
|
|
1000 result = "{}";
|
|
|
1001 return result;
|
|
|
1002 }
|
|
|
1003
|
|
|
1004 VULKAN_HPP_INLINE std::string to_string( SamplerCreateFlags value )
|
|
|
1005 {
|
|
|
1006 std::string result = "{";
|
|
|
1007 if ( value & SamplerCreateFlagBits::eSubsampledEXT )
|
|
|
1008 result += " SubsampledEXT |";
|
|
|
1009 if ( value & SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT )
|
|
|
1010 result += " SubsampledCoarseReconstructionEXT |";
|
|
|
1011 if ( value & SamplerCreateFlagBits::eDescriptorBufferCaptureReplayEXT )
|
|
|
1012 result += " DescriptorBufferCaptureReplayEXT |";
|
|
|
1013 if ( value & SamplerCreateFlagBits::eNonSeamlessCubeMapEXT )
|
|
|
1014 result += " NonSeamlessCubeMapEXT |";
|
|
|
1015 if ( value & SamplerCreateFlagBits::eImageProcessingQCOM )
|
|
|
1016 result += " ImageProcessingQCOM |";
|
|
|
1017
|
|
|
1018 if ( result.size() > 1 )
|
|
|
1019 result.back() = '}';
|
|
|
1020 else
|
|
|
1021 result = "{}";
|
|
|
1022 return result;
|
|
|
1023 }
|
|
|
1024
|
|
|
1025 VULKAN_HPP_INLINE std::string to_string( DescriptorPoolCreateFlags value )
|
|
|
1026 {
|
|
|
1027 std::string result = "{";
|
|
|
1028 if ( value & DescriptorPoolCreateFlagBits::eFreeDescriptorSet )
|
|
|
1029 result += " FreeDescriptorSet |";
|
|
|
1030 if ( value & DescriptorPoolCreateFlagBits::eUpdateAfterBind )
|
|
|
1031 result += " UpdateAfterBind |";
|
|
|
1032 if ( value & DescriptorPoolCreateFlagBits::eHostOnlyEXT )
|
|
|
1033 result += " HostOnlyEXT |";
|
|
|
1034 if ( value & DescriptorPoolCreateFlagBits::eAllowOverallocationSetsNV )
|
|
|
1035 result += " AllowOverallocationSetsNV |";
|
|
|
1036 if ( value & DescriptorPoolCreateFlagBits::eAllowOverallocationPoolsNV )
|
|
|
1037 result += " AllowOverallocationPoolsNV |";
|
|
|
1038
|
|
|
1039 if ( result.size() > 1 )
|
|
|
1040 result.back() = '}';
|
|
|
1041 else
|
|
|
1042 result = "{}";
|
|
|
1043 return result;
|
|
|
1044 }
|
|
|
1045
|
|
|
1046 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorPoolResetFlags )
|
|
|
1047 {
|
|
|
1048 return "{}";
|
|
|
1049 }
|
|
|
1050
|
|
|
1051 VULKAN_HPP_INLINE std::string to_string( DescriptorSetLayoutCreateFlags value )
|
|
|
1052 {
|
|
|
1053 std::string result = "{";
|
|
|
1054 if ( value & DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool )
|
|
|
1055 result += " UpdateAfterBindPool |";
|
|
|
1056 if ( value & DescriptorSetLayoutCreateFlagBits::ePushDescriptor )
|
|
|
1057 result += " PushDescriptor |";
|
|
|
1058 if ( value & DescriptorSetLayoutCreateFlagBits::eDescriptorBufferEXT )
|
|
|
1059 result += " DescriptorBufferEXT |";
|
|
|
1060 if ( value & DescriptorSetLayoutCreateFlagBits::eEmbeddedImmutableSamplersEXT )
|
|
|
1061 result += " EmbeddedImmutableSamplersEXT |";
|
|
|
1062 if ( value & DescriptorSetLayoutCreateFlagBits::eIndirectBindableNV )
|
|
|
1063 result += " IndirectBindableNV |";
|
|
|
1064 if ( value & DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolEXT )
|
|
|
1065 result += " HostOnlyPoolEXT |";
|
|
|
1066 if ( value & DescriptorSetLayoutCreateFlagBits::ePerStageNV )
|
|
|
1067 result += " PerStageNV |";
|
|
|
1068
|
|
|
1069 if ( result.size() > 1 )
|
|
|
1070 result.back() = '}';
|
|
|
1071 else
|
|
|
1072 result = "{}";
|
|
|
1073 return result;
|
|
|
1074 }
|
|
|
1075
|
|
|
1076 VULKAN_HPP_INLINE std::string to_string( QueryPipelineStatisticFlags value )
|
|
|
1077 {
|
|
|
1078 std::string result = "{";
|
|
|
1079 if ( value & QueryPipelineStatisticFlagBits::eInputAssemblyVertices )
|
|
|
1080 result += " InputAssemblyVertices |";
|
|
|
1081 if ( value & QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives )
|
|
|
1082 result += " InputAssemblyPrimitives |";
|
|
|
1083 if ( value & QueryPipelineStatisticFlagBits::eVertexShaderInvocations )
|
|
|
1084 result += " VertexShaderInvocations |";
|
|
|
1085 if ( value & QueryPipelineStatisticFlagBits::eGeometryShaderInvocations )
|
|
|
1086 result += " GeometryShaderInvocations |";
|
|
|
1087 if ( value & QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives )
|
|
|
1088 result += " GeometryShaderPrimitives |";
|
|
|
1089 if ( value & QueryPipelineStatisticFlagBits::eClippingInvocations )
|
|
|
1090 result += " ClippingInvocations |";
|
|
|
1091 if ( value & QueryPipelineStatisticFlagBits::eClippingPrimitives )
|
|
|
1092 result += " ClippingPrimitives |";
|
|
|
1093 if ( value & QueryPipelineStatisticFlagBits::eFragmentShaderInvocations )
|
|
|
1094 result += " FragmentShaderInvocations |";
|
|
|
1095 if ( value & QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches )
|
|
|
1096 result += " TessellationControlShaderPatches |";
|
|
|
1097 if ( value & QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations )
|
|
|
1098 result += " TessellationEvaluationShaderInvocations |";
|
|
|
1099 if ( value & QueryPipelineStatisticFlagBits::eComputeShaderInvocations )
|
|
|
1100 result += " ComputeShaderInvocations |";
|
|
|
1101 if ( value & QueryPipelineStatisticFlagBits::eTaskShaderInvocationsEXT )
|
|
|
1102 result += " TaskShaderInvocationsEXT |";
|
|
|
1103 if ( value & QueryPipelineStatisticFlagBits::eMeshShaderInvocationsEXT )
|
|
|
1104 result += " MeshShaderInvocationsEXT |";
|
|
|
1105 if ( value & QueryPipelineStatisticFlagBits::eClusterCullingShaderInvocationsHUAWEI )
|
|
|
1106 result += " ClusterCullingShaderInvocationsHUAWEI |";
|
|
|
1107
|
|
|
1108 if ( result.size() > 1 )
|
|
|
1109 result.back() = '}';
|
|
|
1110 else
|
|
|
1111 result = "{}";
|
|
|
1112 return result;
|
|
|
1113 }
|
|
|
1114
|
|
|
1115 VULKAN_HPP_INLINE std::string to_string( ColorComponentFlags value )
|
|
|
1116 {
|
|
|
1117 std::string result = "{";
|
|
|
1118 if ( value & ColorComponentFlagBits::eR )
|
|
|
1119 result += " R |";
|
|
|
1120 if ( value & ColorComponentFlagBits::eG )
|
|
|
1121 result += " G |";
|
|
|
1122 if ( value & ColorComponentFlagBits::eB )
|
|
|
1123 result += " B |";
|
|
|
1124 if ( value & ColorComponentFlagBits::eA )
|
|
|
1125 result += " A |";
|
|
|
1126
|
|
|
1127 if ( result.size() > 1 )
|
|
|
1128 result.back() = '}';
|
|
|
1129 else
|
|
|
1130 result = "{}";
|
|
|
1131 return result;
|
|
|
1132 }
|
|
|
1133
|
|
|
1134 VULKAN_HPP_INLINE std::string to_string( CullModeFlags value )
|
|
|
1135 {
|
|
|
1136 std::string result = "{";
|
|
|
1137 if ( value & CullModeFlagBits::eFront )
|
|
|
1138 result += " Front |";
|
|
|
1139 if ( value & CullModeFlagBits::eBack )
|
|
|
1140 result += " Back |";
|
|
|
1141
|
|
|
1142 if ( result.size() > 1 )
|
|
|
1143 result.back() = '}';
|
|
|
1144 else
|
|
|
1145 result = "None";
|
|
|
1146 return result;
|
|
|
1147 }
|
|
|
1148
|
|
|
1149 VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlags value )
|
|
|
1150 {
|
|
|
1151 std::string result = "{";
|
|
|
1152 if ( value & PipelineColorBlendStateCreateFlagBits::eRasterizationOrderAttachmentAccessEXT )
|
|
|
1153 result += " RasterizationOrderAttachmentAccessEXT |";
|
|
|
1154
|
|
|
1155 if ( result.size() > 1 )
|
|
|
1156 result.back() = '}';
|
|
|
1157 else
|
|
|
1158 result = "{}";
|
|
|
1159 return result;
|
|
|
1160 }
|
|
|
1161
|
|
|
1162 VULKAN_HPP_INLINE std::string to_string( PipelineDepthStencilStateCreateFlags value )
|
|
|
1163 {
|
|
|
1164 std::string result = "{";
|
|
|
1165 if ( value & PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentDepthAccessEXT )
|
|
|
1166 result += " RasterizationOrderAttachmentDepthAccessEXT |";
|
|
|
1167 if ( value & PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentStencilAccessEXT )
|
|
|
1168 result += " RasterizationOrderAttachmentStencilAccessEXT |";
|
|
|
1169
|
|
|
1170 if ( result.size() > 1 )
|
|
|
1171 result.back() = '}';
|
|
|
1172 else
|
|
|
1173 result = "{}";
|
|
|
1174 return result;
|
|
|
1175 }
|
|
|
1176
|
|
|
1177 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineDynamicStateCreateFlags )
|
|
|
1178 {
|
|
|
1179 return "{}";
|
|
|
1180 }
|
|
|
1181
|
|
|
1182 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineInputAssemblyStateCreateFlags )
|
|
|
1183 {
|
|
|
1184 return "{}";
|
|
|
1185 }
|
|
|
1186
|
|
|
1187 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineMultisampleStateCreateFlags )
|
|
|
1188 {
|
|
|
1189 return "{}";
|
|
|
1190 }
|
|
|
1191
|
|
|
1192 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRasterizationStateCreateFlags )
|
|
|
1193 {
|
|
|
1194 return "{}";
|
|
|
1195 }
|
|
|
1196
|
|
|
1197 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineTessellationStateCreateFlags )
|
|
|
1198 {
|
|
|
1199 return "{}";
|
|
|
1200 }
|
|
|
1201
|
|
|
1202 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineVertexInputStateCreateFlags )
|
|
|
1203 {
|
|
|
1204 return "{}";
|
|
|
1205 }
|
|
|
1206
|
|
|
1207 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineViewportStateCreateFlags )
|
|
|
1208 {
|
|
|
1209 return "{}";
|
|
|
1210 }
|
|
|
1211
|
|
|
1212 VULKAN_HPP_INLINE std::string to_string( AttachmentDescriptionFlags value )
|
|
|
1213 {
|
|
|
1214 std::string result = "{";
|
|
|
1215 if ( value & AttachmentDescriptionFlagBits::eMayAlias )
|
|
|
1216 result += " MayAlias |";
|
|
|
1217 if ( value & AttachmentDescriptionFlagBits::eResolveSkipTransferFunctionKHR )
|
|
|
1218 result += " ResolveSkipTransferFunctionKHR |";
|
|
|
1219 if ( value & AttachmentDescriptionFlagBits::eResolveEnableTransferFunctionKHR )
|
|
|
1220 result += " ResolveEnableTransferFunctionKHR |";
|
|
|
1221
|
|
|
1222 if ( result.size() > 1 )
|
|
|
1223 result.back() = '}';
|
|
|
1224 else
|
|
|
1225 result = "{}";
|
|
|
1226 return result;
|
|
|
1227 }
|
|
|
1228
|
|
|
1229 VULKAN_HPP_INLINE std::string to_string( FramebufferCreateFlags value )
|
|
|
1230 {
|
|
|
1231 std::string result = "{";
|
|
|
1232 if ( value & FramebufferCreateFlagBits::eImageless )
|
|
|
1233 result += " Imageless |";
|
|
|
1234
|
|
|
1235 if ( result.size() > 1 )
|
|
|
1236 result.back() = '}';
|
|
|
1237 else
|
|
|
1238 result = "{}";
|
|
|
1239 return result;
|
|
|
1240 }
|
|
|
1241
|
|
|
1242 VULKAN_HPP_INLINE std::string to_string( RenderPassCreateFlags value )
|
|
|
1243 {
|
|
|
1244 std::string result = "{";
|
|
|
1245 if ( value & RenderPassCreateFlagBits::eTransformQCOM )
|
|
|
1246 result += " TransformQCOM |";
|
|
|
1247 if ( value & RenderPassCreateFlagBits::ePerLayerFragmentDensityVALVE )
|
|
|
1248 result += " PerLayerFragmentDensityVALVE |";
|
|
|
1249
|
|
|
1250 if ( result.size() > 1 )
|
|
|
1251 result.back() = '}';
|
|
|
1252 else
|
|
|
1253 result = "{}";
|
|
|
1254 return result;
|
|
|
1255 }
|
|
|
1256
|
|
|
1257 VULKAN_HPP_INLINE std::string to_string( SubpassDescriptionFlags value )
|
|
|
1258 {
|
|
|
1259 std::string result = "{";
|
|
|
1260 if ( value & SubpassDescriptionFlagBits::ePerViewAttributesNVX )
|
|
|
1261 result += " PerViewAttributesNVX |";
|
|
|
1262 if ( value & SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX )
|
|
|
1263 result += " PerViewPositionXOnlyNVX |";
|
|
|
1264 if ( value & SubpassDescriptionFlagBits::eTileShadingApronQCOM )
|
|
|
1265 result += " TileShadingApronQCOM |";
|
|
|
1266 if ( value & SubpassDescriptionFlagBits::eRasterizationOrderAttachmentColorAccessEXT )
|
|
|
1267 result += " RasterizationOrderAttachmentColorAccessEXT |";
|
|
|
1268 if ( value & SubpassDescriptionFlagBits::eRasterizationOrderAttachmentDepthAccessEXT )
|
|
|
1269 result += " RasterizationOrderAttachmentDepthAccessEXT |";
|
|
|
1270 if ( value & SubpassDescriptionFlagBits::eRasterizationOrderAttachmentStencilAccessEXT )
|
|
|
1271 result += " RasterizationOrderAttachmentStencilAccessEXT |";
|
|
|
1272 if ( value & SubpassDescriptionFlagBits::eEnableLegacyDitheringEXT )
|
|
|
1273 result += " EnableLegacyDitheringEXT |";
|
|
|
1274 if ( value & SubpassDescriptionFlagBits::eFragmentRegionEXT )
|
|
|
1275 result += " FragmentRegionEXT |";
|
|
|
1276 if ( value & SubpassDescriptionFlagBits::eCustomResolveEXT )
|
|
|
1277 result += " CustomResolveEXT |";
|
|
|
1278
|
|
|
1279 if ( result.size() > 1 )
|
|
|
1280 result.back() = '}';
|
|
|
1281 else
|
|
|
1282 result = "{}";
|
|
|
1283 return result;
|
|
|
1284 }
|
|
|
1285
|
|
|
1286 VULKAN_HPP_INLINE std::string to_string( StencilFaceFlags value )
|
|
|
1287 {
|
|
|
1288 std::string result = "{";
|
|
|
1289 if ( value & StencilFaceFlagBits::eFront )
|
|
|
1290 result += " Front |";
|
|
|
1291 if ( value & StencilFaceFlagBits::eBack )
|
|
|
1292 result += " Back |";
|
|
|
1293
|
|
|
1294 if ( result.size() > 1 )
|
|
|
1295 result.back() = '}';
|
|
|
1296 else
|
|
|
1297 result = "{}";
|
|
|
1298 return result;
|
|
|
1299 }
|
|
|
1300
|
|
|
1301 //=== VK_VERSION_1_1 ===
|
|
|
1302
|
|
|
1303 VULKAN_HPP_INLINE std::string to_string( PeerMemoryFeatureFlags value )
|
|
|
1304 {
|
|
|
1305 std::string result = "{";
|
|
|
1306 if ( value & PeerMemoryFeatureFlagBits::eCopySrc )
|
|
|
1307 result += " CopySrc |";
|
|
|
1308 if ( value & PeerMemoryFeatureFlagBits::eCopyDst )
|
|
|
1309 result += " CopyDst |";
|
|
|
1310 if ( value & PeerMemoryFeatureFlagBits::eGenericSrc )
|
|
|
1311 result += " GenericSrc |";
|
|
|
1312 if ( value & PeerMemoryFeatureFlagBits::eGenericDst )
|
|
|
1313 result += " GenericDst |";
|
|
|
1314
|
|
|
1315 if ( result.size() > 1 )
|
|
|
1316 result.back() = '}';
|
|
|
1317 else
|
|
|
1318 result = "{}";
|
|
|
1319 return result;
|
|
|
1320 }
|
|
|
1321
|
|
|
1322 VULKAN_HPP_INLINE std::string to_string( MemoryAllocateFlags value )
|
|
|
1323 {
|
|
|
1324 std::string result = "{";
|
|
|
1325 if ( value & MemoryAllocateFlagBits::eDeviceMask )
|
|
|
1326 result += " DeviceMask |";
|
|
|
1327 if ( value & MemoryAllocateFlagBits::eDeviceAddress )
|
|
|
1328 result += " DeviceAddress |";
|
|
|
1329 if ( value & MemoryAllocateFlagBits::eDeviceAddressCaptureReplay )
|
|
|
1330 result += " DeviceAddressCaptureReplay |";
|
|
|
1331 if ( value & MemoryAllocateFlagBits::eZeroInitializeEXT )
|
|
|
1332 result += " ZeroInitializeEXT |";
|
|
|
1333
|
|
|
1334 if ( result.size() > 1 )
|
|
|
1335 result.back() = '}';
|
|
|
1336 else
|
|
|
1337 result = "{}";
|
|
|
1338 return result;
|
|
|
1339 }
|
|
|
1340
|
|
|
1341 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CommandPoolTrimFlags )
|
|
|
1342 {
|
|
|
1343 return "{}";
|
|
|
1344 }
|
|
|
1345
|
|
|
1346 VULKAN_HPP_INLINE std::string to_string( ExternalMemoryHandleTypeFlags value )
|
|
|
1347 {
|
|
|
1348 std::string result = "{";
|
|
|
1349 if ( value & ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
|
|
|
1350 result += " OpaqueFd |";
|
|
|
1351 if ( value & ExternalMemoryHandleTypeFlagBits::eOpaqueWin32 )
|
|
|
1352 result += " OpaqueWin32 |";
|
|
|
1353 if ( value & ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt )
|
|
|
1354 result += " OpaqueWin32Kmt |";
|
|
|
1355 if ( value & ExternalMemoryHandleTypeFlagBits::eD3D11Texture )
|
|
|
1356 result += " D3D11Texture |";
|
|
|
1357 if ( value & ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt )
|
|
|
1358 result += " D3D11TextureKmt |";
|
|
|
1359 if ( value & ExternalMemoryHandleTypeFlagBits::eD3D12Heap )
|
|
|
1360 result += " D3D12Heap |";
|
|
|
1361 if ( value & ExternalMemoryHandleTypeFlagBits::eD3D12Resource )
|
|
|
1362 result += " D3D12Resource |";
|
|
|
1363 if ( value & ExternalMemoryHandleTypeFlagBits::eDmaBufEXT )
|
|
|
1364 result += " DmaBufEXT |";
|
|
|
1365 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
|
1366 if ( value & ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID )
|
|
|
1367 result += " AndroidHardwareBufferANDROID |";
|
|
|
1368 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
1369 if ( value & ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT )
|
|
|
1370 result += " HostAllocationEXT |";
|
|
|
1371 if ( value & ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT )
|
|
|
1372 result += " HostMappedForeignMemoryEXT |";
|
|
|
1373 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
1374 if ( value & ExternalMemoryHandleTypeFlagBits::eZirconVmoFUCHSIA )
|
|
|
1375 result += " ZirconVmoFUCHSIA |";
|
|
|
1376 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
1377 if ( value & ExternalMemoryHandleTypeFlagBits::eRdmaAddressNV )
|
|
|
1378 result += " RdmaAddressNV |";
|
|
|
1379 #if defined( VK_USE_PLATFORM_OHOS )
|
|
|
1380 if ( value & ExternalMemoryHandleTypeFlagBits::eOhNativeBufferOHOS )
|
|
|
1381 result += " OhNativeBufferOHOS |";
|
|
|
1382 #endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
1383 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
|
1384 if ( value & ExternalMemoryHandleTypeFlagBits::eScreenBufferQNX )
|
|
|
1385 result += " ScreenBufferQNX |";
|
|
|
1386 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
|
1387 #if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
1388 if ( value & ExternalMemoryHandleTypeFlagBits::eMtlbufferEXT )
|
|
|
1389 result += " MtlbufferEXT |";
|
|
|
1390 if ( value & ExternalMemoryHandleTypeFlagBits::eMtltextureEXT )
|
|
|
1391 result += " MtltextureEXT |";
|
|
|
1392 if ( value & ExternalMemoryHandleTypeFlagBits::eMtlheapEXT )
|
|
|
1393 result += " MtlheapEXT |";
|
|
|
1394 #endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
1395
|
|
|
1396 if ( result.size() > 1 )
|
|
|
1397 result.back() = '}';
|
|
|
1398 else
|
|
|
1399 result = "{}";
|
|
|
1400 return result;
|
|
|
1401 }
|
|
|
1402
|
|
|
1403 VULKAN_HPP_INLINE std::string to_string( ExternalMemoryFeatureFlags value )
|
|
|
1404 {
|
|
|
1405 std::string result = "{";
|
|
|
1406 if ( value & ExternalMemoryFeatureFlagBits::eDedicatedOnly )
|
|
|
1407 result += " DedicatedOnly |";
|
|
|
1408 if ( value & ExternalMemoryFeatureFlagBits::eExportable )
|
|
|
1409 result += " Exportable |";
|
|
|
1410 if ( value & ExternalMemoryFeatureFlagBits::eImportable )
|
|
|
1411 result += " Importable |";
|
|
|
1412
|
|
|
1413 if ( result.size() > 1 )
|
|
|
1414 result.back() = '}';
|
|
|
1415 else
|
|
|
1416 result = "{}";
|
|
|
1417 return result;
|
|
|
1418 }
|
|
|
1419
|
|
|
1420 VULKAN_HPP_INLINE std::string to_string( ExternalFenceHandleTypeFlags value )
|
|
|
1421 {
|
|
|
1422 std::string result = "{";
|
|
|
1423 if ( value & ExternalFenceHandleTypeFlagBits::eOpaqueFd )
|
|
|
1424 result += " OpaqueFd |";
|
|
|
1425 if ( value & ExternalFenceHandleTypeFlagBits::eOpaqueWin32 )
|
|
|
1426 result += " OpaqueWin32 |";
|
|
|
1427 if ( value & ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt )
|
|
|
1428 result += " OpaqueWin32Kmt |";
|
|
|
1429 if ( value & ExternalFenceHandleTypeFlagBits::eSyncFd )
|
|
|
1430 result += " SyncFd |";
|
|
|
1431
|
|
|
1432 if ( result.size() > 1 )
|
|
|
1433 result.back() = '}';
|
|
|
1434 else
|
|
|
1435 result = "{}";
|
|
|
1436 return result;
|
|
|
1437 }
|
|
|
1438
|
|
|
1439 VULKAN_HPP_INLINE std::string to_string( ExternalFenceFeatureFlags value )
|
|
|
1440 {
|
|
|
1441 std::string result = "{";
|
|
|
1442 if ( value & ExternalFenceFeatureFlagBits::eExportable )
|
|
|
1443 result += " Exportable |";
|
|
|
1444 if ( value & ExternalFenceFeatureFlagBits::eImportable )
|
|
|
1445 result += " Importable |";
|
|
|
1446
|
|
|
1447 if ( result.size() > 1 )
|
|
|
1448 result.back() = '}';
|
|
|
1449 else
|
|
|
1450 result = "{}";
|
|
|
1451 return result;
|
|
|
1452 }
|
|
|
1453
|
|
|
1454 VULKAN_HPP_INLINE std::string to_string( FenceImportFlags value )
|
|
|
1455 {
|
|
|
1456 std::string result = "{";
|
|
|
1457 if ( value & FenceImportFlagBits::eTemporary )
|
|
|
1458 result += " Temporary |";
|
|
|
1459
|
|
|
1460 if ( result.size() > 1 )
|
|
|
1461 result.back() = '}';
|
|
|
1462 else
|
|
|
1463 result = "{}";
|
|
|
1464 return result;
|
|
|
1465 }
|
|
|
1466
|
|
|
1467 VULKAN_HPP_INLINE std::string to_string( SemaphoreImportFlags value )
|
|
|
1468 {
|
|
|
1469 std::string result = "{";
|
|
|
1470 if ( value & SemaphoreImportFlagBits::eTemporary )
|
|
|
1471 result += " Temporary |";
|
|
|
1472
|
|
|
1473 if ( result.size() > 1 )
|
|
|
1474 result.back() = '}';
|
|
|
1475 else
|
|
|
1476 result = "{}";
|
|
|
1477 return result;
|
|
|
1478 }
|
|
|
1479
|
|
|
1480 VULKAN_HPP_INLINE std::string to_string( ExternalSemaphoreHandleTypeFlags value )
|
|
|
1481 {
|
|
|
1482 std::string result = "{";
|
|
|
1483 if ( value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
|
|
|
1484 result += " OpaqueFd |";
|
|
|
1485 if ( value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32 )
|
|
|
1486 result += " OpaqueWin32 |";
|
|
|
1487 if ( value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt )
|
|
|
1488 result += " OpaqueWin32Kmt |";
|
|
|
1489 if ( value & ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence )
|
|
|
1490 result += " D3D12Fence |";
|
|
|
1491 if ( value & ExternalSemaphoreHandleTypeFlagBits::eSyncFd )
|
|
|
1492 result += " SyncFd |";
|
|
|
1493 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
1494 if ( value & ExternalSemaphoreHandleTypeFlagBits::eZirconEventFUCHSIA )
|
|
|
1495 result += " ZirconEventFUCHSIA |";
|
|
|
1496 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
1497
|
|
|
1498 if ( result.size() > 1 )
|
|
|
1499 result.back() = '}';
|
|
|
1500 else
|
|
|
1501 result = "{}";
|
|
|
1502 return result;
|
|
|
1503 }
|
|
|
1504
|
|
|
1505 VULKAN_HPP_INLINE std::string to_string( ExternalSemaphoreFeatureFlags value )
|
|
|
1506 {
|
|
|
1507 std::string result = "{";
|
|
|
1508 if ( value & ExternalSemaphoreFeatureFlagBits::eExportable )
|
|
|
1509 result += " Exportable |";
|
|
|
1510 if ( value & ExternalSemaphoreFeatureFlagBits::eImportable )
|
|
|
1511 result += " Importable |";
|
|
|
1512
|
|
|
1513 if ( result.size() > 1 )
|
|
|
1514 result.back() = '}';
|
|
|
1515 else
|
|
|
1516 result = "{}";
|
|
|
1517 return result;
|
|
|
1518 }
|
|
|
1519
|
|
|
1520 VULKAN_HPP_INLINE std::string to_string( SubgroupFeatureFlags value )
|
|
|
1521 {
|
|
|
1522 std::string result = "{";
|
|
|
1523 if ( value & SubgroupFeatureFlagBits::eBasic )
|
|
|
1524 result += " Basic |";
|
|
|
1525 if ( value & SubgroupFeatureFlagBits::eVote )
|
|
|
1526 result += " Vote |";
|
|
|
1527 if ( value & SubgroupFeatureFlagBits::eArithmetic )
|
|
|
1528 result += " Arithmetic |";
|
|
|
1529 if ( value & SubgroupFeatureFlagBits::eBallot )
|
|
|
1530 result += " Ballot |";
|
|
|
1531 if ( value & SubgroupFeatureFlagBits::eShuffle )
|
|
|
1532 result += " Shuffle |";
|
|
|
1533 if ( value & SubgroupFeatureFlagBits::eShuffleRelative )
|
|
|
1534 result += " ShuffleRelative |";
|
|
|
1535 if ( value & SubgroupFeatureFlagBits::eClustered )
|
|
|
1536 result += " Clustered |";
|
|
|
1537 if ( value & SubgroupFeatureFlagBits::eQuad )
|
|
|
1538 result += " Quad |";
|
|
|
1539 if ( value & SubgroupFeatureFlagBits::eRotate )
|
|
|
1540 result += " Rotate |";
|
|
|
1541 if ( value & SubgroupFeatureFlagBits::eRotateClustered )
|
|
|
1542 result += " RotateClustered |";
|
|
|
1543 if ( value & SubgroupFeatureFlagBits::ePartitionedNV )
|
|
|
1544 result += " PartitionedNV |";
|
|
|
1545
|
|
|
1546 if ( result.size() > 1 )
|
|
|
1547 result.back() = '}';
|
|
|
1548 else
|
|
|
1549 result = "{}";
|
|
|
1550 return result;
|
|
|
1551 }
|
|
|
1552
|
|
|
1553 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorUpdateTemplateCreateFlags )
|
|
|
1554 {
|
|
|
1555 return "{}";
|
|
|
1556 }
|
|
|
1557
|
|
|
1558 //=== VK_VERSION_1_2 ===
|
|
|
1559
|
|
|
1560 VULKAN_HPP_INLINE std::string to_string( SemaphoreWaitFlags value )
|
|
|
1561 {
|
|
|
1562 std::string result = "{";
|
|
|
1563 if ( value & SemaphoreWaitFlagBits::eAny )
|
|
|
1564 result += " Any |";
|
|
|
1565
|
|
|
1566 if ( result.size() > 1 )
|
|
|
1567 result.back() = '}';
|
|
|
1568 else
|
|
|
1569 result = "{}";
|
|
|
1570 return result;
|
|
|
1571 }
|
|
|
1572
|
|
|
1573 VULKAN_HPP_INLINE std::string to_string( DescriptorBindingFlags value )
|
|
|
1574 {
|
|
|
1575 std::string result = "{";
|
|
|
1576 if ( value & DescriptorBindingFlagBits::eUpdateAfterBind )
|
|
|
1577 result += " UpdateAfterBind |";
|
|
|
1578 if ( value & DescriptorBindingFlagBits::eUpdateUnusedWhilePending )
|
|
|
1579 result += " UpdateUnusedWhilePending |";
|
|
|
1580 if ( value & DescriptorBindingFlagBits::ePartiallyBound )
|
|
|
1581 result += " PartiallyBound |";
|
|
|
1582 if ( value & DescriptorBindingFlagBits::eVariableDescriptorCount )
|
|
|
1583 result += " VariableDescriptorCount |";
|
|
|
1584
|
|
|
1585 if ( result.size() > 1 )
|
|
|
1586 result.back() = '}';
|
|
|
1587 else
|
|
|
1588 result = "{}";
|
|
|
1589 return result;
|
|
|
1590 }
|
|
|
1591
|
|
|
1592 VULKAN_HPP_INLINE std::string to_string( ResolveModeFlags value )
|
|
|
1593 {
|
|
|
1594 std::string result = "{";
|
|
|
1595 if ( value & ResolveModeFlagBits::eSampleZero )
|
|
|
1596 result += " SampleZero |";
|
|
|
1597 if ( value & ResolveModeFlagBits::eAverage )
|
|
|
1598 result += " Average |";
|
|
|
1599 if ( value & ResolveModeFlagBits::eMin )
|
|
|
1600 result += " Min |";
|
|
|
1601 if ( value & ResolveModeFlagBits::eMax )
|
|
|
1602 result += " Max |";
|
|
|
1603 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
|
1604 if ( value & ResolveModeFlagBits::eExternalFormatDownsampleANDROID )
|
|
|
1605 result += " ExternalFormatDownsampleANDROID |";
|
|
|
1606 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
1607 if ( value & ResolveModeFlagBits::eCustomEXT )
|
|
|
1608 result += " CustomEXT |";
|
|
|
1609
|
|
|
1610 if ( result.size() > 1 )
|
|
|
1611 result.back() = '}';
|
|
|
1612 else
|
|
|
1613 result = "None";
|
|
|
1614 return result;
|
|
|
1615 }
|
|
|
1616
|
|
|
1617 //=== VK_VERSION_1_3 ===
|
|
|
1618
|
|
|
1619 VULKAN_HPP_INLINE std::string to_string( ToolPurposeFlags value )
|
|
|
1620 {
|
|
|
1621 std::string result = "{";
|
|
|
1622 if ( value & ToolPurposeFlagBits::eValidation )
|
|
|
1623 result += " Validation |";
|
|
|
1624 if ( value & ToolPurposeFlagBits::eProfiling )
|
|
|
1625 result += " Profiling |";
|
|
|
1626 if ( value & ToolPurposeFlagBits::eTracing )
|
|
|
1627 result += " Tracing |";
|
|
|
1628 if ( value & ToolPurposeFlagBits::eAdditionalFeatures )
|
|
|
1629 result += " AdditionalFeatures |";
|
|
|
1630 if ( value & ToolPurposeFlagBits::eModifyingFeatures )
|
|
|
1631 result += " ModifyingFeatures |";
|
|
|
1632 if ( value & ToolPurposeFlagBits::eDebugReportingEXT )
|
|
|
1633 result += " DebugReportingEXT |";
|
|
|
1634 if ( value & ToolPurposeFlagBits::eDebugMarkersEXT )
|
|
|
1635 result += " DebugMarkersEXT |";
|
|
|
1636
|
|
|
1637 if ( result.size() > 1 )
|
|
|
1638 result.back() = '}';
|
|
|
1639 else
|
|
|
1640 result = "{}";
|
|
|
1641 return result;
|
|
|
1642 }
|
|
|
1643
|
|
|
1644 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PrivateDataSlotCreateFlags )
|
|
|
1645 {
|
|
|
1646 return "{}";
|
|
|
1647 }
|
|
|
1648
|
|
|
1649 VULKAN_HPP_INLINE std::string to_string( PipelineStageFlags2 value )
|
|
|
1650 {
|
|
|
1651 std::string result = "{";
|
|
|
1652 if ( value & PipelineStageFlagBits2::eTopOfPipe )
|
|
|
1653 result += " TopOfPipe |";
|
|
|
1654 if ( value & PipelineStageFlagBits2::eDrawIndirect )
|
|
|
1655 result += " DrawIndirect |";
|
|
|
1656 if ( value & PipelineStageFlagBits2::eVertexInput )
|
|
|
1657 result += " VertexInput |";
|
|
|
1658 if ( value & PipelineStageFlagBits2::eVertexShader )
|
|
|
1659 result += " VertexShader |";
|
|
|
1660 if ( value & PipelineStageFlagBits2::eTessellationControlShader )
|
|
|
1661 result += " TessellationControlShader |";
|
|
|
1662 if ( value & PipelineStageFlagBits2::eTessellationEvaluationShader )
|
|
|
1663 result += " TessellationEvaluationShader |";
|
|
|
1664 if ( value & PipelineStageFlagBits2::eGeometryShader )
|
|
|
1665 result += " GeometryShader |";
|
|
|
1666 if ( value & PipelineStageFlagBits2::eFragmentShader )
|
|
|
1667 result += " FragmentShader |";
|
|
|
1668 if ( value & PipelineStageFlagBits2::eEarlyFragmentTests )
|
|
|
1669 result += " EarlyFragmentTests |";
|
|
|
1670 if ( value & PipelineStageFlagBits2::eLateFragmentTests )
|
|
|
1671 result += " LateFragmentTests |";
|
|
|
1672 if ( value & PipelineStageFlagBits2::eColorAttachmentOutput )
|
|
|
1673 result += " ColorAttachmentOutput |";
|
|
|
1674 if ( value & PipelineStageFlagBits2::eComputeShader )
|
|
|
1675 result += " ComputeShader |";
|
|
|
1676 if ( value & PipelineStageFlagBits2::eAllTransfer )
|
|
|
1677 result += " AllTransfer |";
|
|
|
1678 if ( value & PipelineStageFlagBits2::eBottomOfPipe )
|
|
|
1679 result += " BottomOfPipe |";
|
|
|
1680 if ( value & PipelineStageFlagBits2::eHost )
|
|
|
1681 result += " Host |";
|
|
|
1682 if ( value & PipelineStageFlagBits2::eAllGraphics )
|
|
|
1683 result += " AllGraphics |";
|
|
|
1684 if ( value & PipelineStageFlagBits2::eAllCommands )
|
|
|
1685 result += " AllCommands |";
|
|
|
1686 if ( value & PipelineStageFlagBits2::eCopy )
|
|
|
1687 result += " Copy |";
|
|
|
1688 if ( value & PipelineStageFlagBits2::eResolve )
|
|
|
1689 result += " Resolve |";
|
|
|
1690 if ( value & PipelineStageFlagBits2::eBlit )
|
|
|
1691 result += " Blit |";
|
|
|
1692 if ( value & PipelineStageFlagBits2::eClear )
|
|
|
1693 result += " Clear |";
|
|
|
1694 if ( value & PipelineStageFlagBits2::eIndexInput )
|
|
|
1695 result += " IndexInput |";
|
|
|
1696 if ( value & PipelineStageFlagBits2::eVertexAttributeInput )
|
|
|
1697 result += " VertexAttributeInput |";
|
|
|
1698 if ( value & PipelineStageFlagBits2::ePreRasterizationShaders )
|
|
|
1699 result += " PreRasterizationShaders |";
|
|
|
1700 if ( value & PipelineStageFlagBits2::eVideoDecodeKHR )
|
|
|
1701 result += " VideoDecodeKHR |";
|
|
|
1702 if ( value & PipelineStageFlagBits2::eVideoEncodeKHR )
|
|
|
1703 result += " VideoEncodeKHR |";
|
|
|
1704 if ( value & PipelineStageFlagBits2::eTransformFeedbackEXT )
|
|
|
1705 result += " TransformFeedbackEXT |";
|
|
|
1706 if ( value & PipelineStageFlagBits2::eConditionalRenderingEXT )
|
|
|
1707 result += " ConditionalRenderingEXT |";
|
|
|
1708 if ( value & PipelineStageFlagBits2::eCommandPreprocessEXT )
|
|
|
1709 result += " CommandPreprocessEXT |";
|
|
|
1710 if ( value & PipelineStageFlagBits2::eFragmentShadingRateAttachmentKHR )
|
|
|
1711 result += " FragmentShadingRateAttachmentKHR |";
|
|
|
1712 if ( value & PipelineStageFlagBits2::eAccelerationStructureBuildKHR )
|
|
|
1713 result += " AccelerationStructureBuildKHR |";
|
|
|
1714 if ( value & PipelineStageFlagBits2::eRayTracingShaderKHR )
|
|
|
1715 result += " RayTracingShaderKHR |";
|
|
|
1716 if ( value & PipelineStageFlagBits2::eFragmentDensityProcessEXT )
|
|
|
1717 result += " FragmentDensityProcessEXT |";
|
|
|
1718 if ( value & PipelineStageFlagBits2::eTaskShaderEXT )
|
|
|
1719 result += " TaskShaderEXT |";
|
|
|
1720 if ( value & PipelineStageFlagBits2::eMeshShaderEXT )
|
|
|
1721 result += " MeshShaderEXT |";
|
|
|
1722 if ( value & PipelineStageFlagBits2::eSubpassShaderHUAWEI )
|
|
|
1723 result += " SubpassShaderHUAWEI |";
|
|
|
1724 if ( value & PipelineStageFlagBits2::eInvocationMaskHUAWEI )
|
|
|
1725 result += " InvocationMaskHUAWEI |";
|
|
|
1726 if ( value & PipelineStageFlagBits2::eAccelerationStructureCopyKHR )
|
|
|
1727 result += " AccelerationStructureCopyKHR |";
|
|
|
1728 if ( value & PipelineStageFlagBits2::eMicromapBuildEXT )
|
|
|
1729 result += " MicromapBuildEXT |";
|
|
|
1730 if ( value & PipelineStageFlagBits2::eClusterCullingShaderHUAWEI )
|
|
|
1731 result += " ClusterCullingShaderHUAWEI |";
|
|
|
1732 if ( value & PipelineStageFlagBits2::eOpticalFlowNV )
|
|
|
1733 result += " OpticalFlowNV |";
|
|
|
1734 if ( value & PipelineStageFlagBits2::eConvertCooperativeVectorMatrixNV )
|
|
|
1735 result += " ConvertCooperativeVectorMatrixNV |";
|
|
|
1736 if ( value & PipelineStageFlagBits2::eDataGraphARM )
|
|
|
1737 result += " DataGraphARM |";
|
|
|
1738 if ( value & PipelineStageFlagBits2::eCopyIndirectKHR )
|
|
|
1739 result += " CopyIndirectKHR |";
|
|
|
1740 if ( value & PipelineStageFlagBits2::eMemoryDecompressionEXT )
|
|
|
1741 result += " MemoryDecompressionEXT |";
|
|
|
1742
|
|
|
1743 if ( result.size() > 1 )
|
|
|
1744 result.back() = '}';
|
|
|
1745 else
|
|
|
1746 result = "None";
|
|
|
1747 return result;
|
|
|
1748 }
|
|
|
1749
|
|
|
1750 VULKAN_HPP_INLINE std::string to_string( AccessFlags2 value )
|
|
|
1751 {
|
|
|
1752 std::string result = "{";
|
|
|
1753 if ( value & AccessFlagBits2::eIndirectCommandRead )
|
|
|
1754 result += " IndirectCommandRead |";
|
|
|
1755 if ( value & AccessFlagBits2::eIndexRead )
|
|
|
1756 result += " IndexRead |";
|
|
|
1757 if ( value & AccessFlagBits2::eVertexAttributeRead )
|
|
|
1758 result += " VertexAttributeRead |";
|
|
|
1759 if ( value & AccessFlagBits2::eUniformRead )
|
|
|
1760 result += " UniformRead |";
|
|
|
1761 if ( value & AccessFlagBits2::eInputAttachmentRead )
|
|
|
1762 result += " InputAttachmentRead |";
|
|
|
1763 if ( value & AccessFlagBits2::eShaderRead )
|
|
|
1764 result += " ShaderRead |";
|
|
|
1765 if ( value & AccessFlagBits2::eShaderWrite )
|
|
|
1766 result += " ShaderWrite |";
|
|
|
1767 if ( value & AccessFlagBits2::eColorAttachmentRead )
|
|
|
1768 result += " ColorAttachmentRead |";
|
|
|
1769 if ( value & AccessFlagBits2::eColorAttachmentWrite )
|
|
|
1770 result += " ColorAttachmentWrite |";
|
|
|
1771 if ( value & AccessFlagBits2::eDepthStencilAttachmentRead )
|
|
|
1772 result += " DepthStencilAttachmentRead |";
|
|
|
1773 if ( value & AccessFlagBits2::eDepthStencilAttachmentWrite )
|
|
|
1774 result += " DepthStencilAttachmentWrite |";
|
|
|
1775 if ( value & AccessFlagBits2::eTransferRead )
|
|
|
1776 result += " TransferRead |";
|
|
|
1777 if ( value & AccessFlagBits2::eTransferWrite )
|
|
|
1778 result += " TransferWrite |";
|
|
|
1779 if ( value & AccessFlagBits2::eHostRead )
|
|
|
1780 result += " HostRead |";
|
|
|
1781 if ( value & AccessFlagBits2::eHostWrite )
|
|
|
1782 result += " HostWrite |";
|
|
|
1783 if ( value & AccessFlagBits2::eMemoryRead )
|
|
|
1784 result += " MemoryRead |";
|
|
|
1785 if ( value & AccessFlagBits2::eMemoryWrite )
|
|
|
1786 result += " MemoryWrite |";
|
|
|
1787 if ( value & AccessFlagBits2::eShaderSampledRead )
|
|
|
1788 result += " ShaderSampledRead |";
|
|
|
1789 if ( value & AccessFlagBits2::eShaderStorageRead )
|
|
|
1790 result += " ShaderStorageRead |";
|
|
|
1791 if ( value & AccessFlagBits2::eShaderStorageWrite )
|
|
|
1792 result += " ShaderStorageWrite |";
|
|
|
1793 if ( value & AccessFlagBits2::eVideoDecodeReadKHR )
|
|
|
1794 result += " VideoDecodeReadKHR |";
|
|
|
1795 if ( value & AccessFlagBits2::eVideoDecodeWriteKHR )
|
|
|
1796 result += " VideoDecodeWriteKHR |";
|
|
|
1797 if ( value & AccessFlagBits2::eVideoEncodeReadKHR )
|
|
|
1798 result += " VideoEncodeReadKHR |";
|
|
|
1799 if ( value & AccessFlagBits2::eVideoEncodeWriteKHR )
|
|
|
1800 result += " VideoEncodeWriteKHR |";
|
|
|
1801 if ( value & AccessFlagBits2::eShaderTileAttachmentReadQCOM )
|
|
|
1802 result += " ShaderTileAttachmentReadQCOM |";
|
|
|
1803 if ( value & AccessFlagBits2::eShaderTileAttachmentWriteQCOM )
|
|
|
1804 result += " ShaderTileAttachmentWriteQCOM |";
|
|
|
1805 if ( value & AccessFlagBits2::eTransformFeedbackWriteEXT )
|
|
|
1806 result += " TransformFeedbackWriteEXT |";
|
|
|
1807 if ( value & AccessFlagBits2::eTransformFeedbackCounterReadEXT )
|
|
|
1808 result += " TransformFeedbackCounterReadEXT |";
|
|
|
1809 if ( value & AccessFlagBits2::eTransformFeedbackCounterWriteEXT )
|
|
|
1810 result += " TransformFeedbackCounterWriteEXT |";
|
|
|
1811 if ( value & AccessFlagBits2::eConditionalRenderingReadEXT )
|
|
|
1812 result += " ConditionalRenderingReadEXT |";
|
|
|
1813 if ( value & AccessFlagBits2::eCommandPreprocessReadEXT )
|
|
|
1814 result += " CommandPreprocessReadEXT |";
|
|
|
1815 if ( value & AccessFlagBits2::eCommandPreprocessWriteEXT )
|
|
|
1816 result += " CommandPreprocessWriteEXT |";
|
|
|
1817 if ( value & AccessFlagBits2::eFragmentShadingRateAttachmentReadKHR )
|
|
|
1818 result += " FragmentShadingRateAttachmentReadKHR |";
|
|
|
1819 if ( value & AccessFlagBits2::eAccelerationStructureReadKHR )
|
|
|
1820 result += " AccelerationStructureReadKHR |";
|
|
|
1821 if ( value & AccessFlagBits2::eAccelerationStructureWriteKHR )
|
|
|
1822 result += " AccelerationStructureWriteKHR |";
|
|
|
1823 if ( value & AccessFlagBits2::eFragmentDensityMapReadEXT )
|
|
|
1824 result += " FragmentDensityMapReadEXT |";
|
|
|
1825 if ( value & AccessFlagBits2::eColorAttachmentReadNoncoherentEXT )
|
|
|
1826 result += " ColorAttachmentReadNoncoherentEXT |";
|
|
|
1827 if ( value & AccessFlagBits2::eDescriptorBufferReadEXT )
|
|
|
1828 result += " DescriptorBufferReadEXT |";
|
|
|
1829 if ( value & AccessFlagBits2::eInvocationMaskReadHUAWEI )
|
|
|
1830 result += " InvocationMaskReadHUAWEI |";
|
|
|
1831 if ( value & AccessFlagBits2::eShaderBindingTableReadKHR )
|
|
|
1832 result += " ShaderBindingTableReadKHR |";
|
|
|
1833 if ( value & AccessFlagBits2::eMicromapReadEXT )
|
|
|
1834 result += " MicromapReadEXT |";
|
|
|
1835 if ( value & AccessFlagBits2::eMicromapWriteEXT )
|
|
|
1836 result += " MicromapWriteEXT |";
|
|
|
1837 if ( value & AccessFlagBits2::eOpticalFlowReadNV )
|
|
|
1838 result += " OpticalFlowReadNV |";
|
|
|
1839 if ( value & AccessFlagBits2::eOpticalFlowWriteNV )
|
|
|
1840 result += " OpticalFlowWriteNV |";
|
|
|
1841 if ( value & AccessFlagBits2::eDataGraphReadARM )
|
|
|
1842 result += " DataGraphReadARM |";
|
|
|
1843 if ( value & AccessFlagBits2::eDataGraphWriteARM )
|
|
|
1844 result += " DataGraphWriteARM |";
|
|
|
1845 if ( value & AccessFlagBits2::eMemoryDecompressionReadEXT )
|
|
|
1846 result += " MemoryDecompressionReadEXT |";
|
|
|
1847 if ( value & AccessFlagBits2::eMemoryDecompressionWriteEXT )
|
|
|
1848 result += " MemoryDecompressionWriteEXT |";
|
|
|
1849
|
|
|
1850 if ( result.size() > 1 )
|
|
|
1851 result.back() = '}';
|
|
|
1852 else
|
|
|
1853 result = "None";
|
|
|
1854 return result;
|
|
|
1855 }
|
|
|
1856
|
|
|
1857 VULKAN_HPP_INLINE std::string to_string( SubmitFlags value )
|
|
|
1858 {
|
|
|
1859 std::string result = "{";
|
|
|
1860 if ( value & SubmitFlagBits::eProtected )
|
|
|
1861 result += " Protected |";
|
|
|
1862
|
|
|
1863 if ( result.size() > 1 )
|
|
|
1864 result.back() = '}';
|
|
|
1865 else
|
|
|
1866 result = "{}";
|
|
|
1867 return result;
|
|
|
1868 }
|
|
|
1869
|
|
|
1870 VULKAN_HPP_INLINE std::string to_string( FormatFeatureFlags2 value )
|
|
|
1871 {
|
|
|
1872 std::string result = "{";
|
|
|
1873 if ( value & FormatFeatureFlagBits2::eSampledImage )
|
|
|
1874 result += " SampledImage |";
|
|
|
1875 if ( value & FormatFeatureFlagBits2::eStorageImage )
|
|
|
1876 result += " StorageImage |";
|
|
|
1877 if ( value & FormatFeatureFlagBits2::eStorageImageAtomic )
|
|
|
1878 result += " StorageImageAtomic |";
|
|
|
1879 if ( value & FormatFeatureFlagBits2::eUniformTexelBuffer )
|
|
|
1880 result += " UniformTexelBuffer |";
|
|
|
1881 if ( value & FormatFeatureFlagBits2::eStorageTexelBuffer )
|
|
|
1882 result += " StorageTexelBuffer |";
|
|
|
1883 if ( value & FormatFeatureFlagBits2::eStorageTexelBufferAtomic )
|
|
|
1884 result += " StorageTexelBufferAtomic |";
|
|
|
1885 if ( value & FormatFeatureFlagBits2::eVertexBuffer )
|
|
|
1886 result += " VertexBuffer |";
|
|
|
1887 if ( value & FormatFeatureFlagBits2::eColorAttachment )
|
|
|
1888 result += " ColorAttachment |";
|
|
|
1889 if ( value & FormatFeatureFlagBits2::eColorAttachmentBlend )
|
|
|
1890 result += " ColorAttachmentBlend |";
|
|
|
1891 if ( value & FormatFeatureFlagBits2::eDepthStencilAttachment )
|
|
|
1892 result += " DepthStencilAttachment |";
|
|
|
1893 if ( value & FormatFeatureFlagBits2::eBlitSrc )
|
|
|
1894 result += " BlitSrc |";
|
|
|
1895 if ( value & FormatFeatureFlagBits2::eBlitDst )
|
|
|
1896 result += " BlitDst |";
|
|
|
1897 if ( value & FormatFeatureFlagBits2::eSampledImageFilterLinear )
|
|
|
1898 result += " SampledImageFilterLinear |";
|
|
|
1899 if ( value & FormatFeatureFlagBits2::eTransferSrc )
|
|
|
1900 result += " TransferSrc |";
|
|
|
1901 if ( value & FormatFeatureFlagBits2::eTransferDst )
|
|
|
1902 result += " TransferDst |";
|
|
|
1903 if ( value & FormatFeatureFlagBits2::eSampledImageFilterMinmax )
|
|
|
1904 result += " SampledImageFilterMinmax |";
|
|
|
1905 if ( value & FormatFeatureFlagBits2::eMidpointChromaSamples )
|
|
|
1906 result += " MidpointChromaSamples |";
|
|
|
1907 if ( value & FormatFeatureFlagBits2::eSampledImageYcbcrConversionLinearFilter )
|
|
|
1908 result += " SampledImageYcbcrConversionLinearFilter |";
|
|
|
1909 if ( value & FormatFeatureFlagBits2::eSampledImageYcbcrConversionSeparateReconstructionFilter )
|
|
|
1910 result += " SampledImageYcbcrConversionSeparateReconstructionFilter |";
|
|
|
1911 if ( value & FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicit )
|
|
|
1912 result += " SampledImageYcbcrConversionChromaReconstructionExplicit |";
|
|
|
1913 if ( value & FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable )
|
|
|
1914 result += " SampledImageYcbcrConversionChromaReconstructionExplicitForceable |";
|
|
|
1915 if ( value & FormatFeatureFlagBits2::eDisjoint )
|
|
|
1916 result += " Disjoint |";
|
|
|
1917 if ( value & FormatFeatureFlagBits2::eCositedChromaSamples )
|
|
|
1918 result += " CositedChromaSamples |";
|
|
|
1919 if ( value & FormatFeatureFlagBits2::eStorageReadWithoutFormat )
|
|
|
1920 result += " StorageReadWithoutFormat |";
|
|
|
1921 if ( value & FormatFeatureFlagBits2::eStorageWriteWithoutFormat )
|
|
|
1922 result += " StorageWriteWithoutFormat |";
|
|
|
1923 if ( value & FormatFeatureFlagBits2::eSampledImageDepthComparison )
|
|
|
1924 result += " SampledImageDepthComparison |";
|
|
|
1925 if ( value & FormatFeatureFlagBits2::eSampledImageFilterCubic )
|
|
|
1926 result += " SampledImageFilterCubic |";
|
|
|
1927 if ( value & FormatFeatureFlagBits2::eHostImageTransfer )
|
|
|
1928 result += " HostImageTransfer |";
|
|
|
1929 if ( value & FormatFeatureFlagBits2::eVideoDecodeOutputKHR )
|
|
|
1930 result += " VideoDecodeOutputKHR |";
|
|
|
1931 if ( value & FormatFeatureFlagBits2::eVideoDecodeDpbKHR )
|
|
|
1932 result += " VideoDecodeDpbKHR |";
|
|
|
1933 if ( value & FormatFeatureFlagBits2::eAccelerationStructureVertexBufferKHR )
|
|
|
1934 result += " AccelerationStructureVertexBufferKHR |";
|
|
|
1935 if ( value & FormatFeatureFlagBits2::eFragmentDensityMapEXT )
|
|
|
1936 result += " FragmentDensityMapEXT |";
|
|
|
1937 if ( value & FormatFeatureFlagBits2::eFragmentShadingRateAttachmentKHR )
|
|
|
1938 result += " FragmentShadingRateAttachmentKHR |";
|
|
|
1939 if ( value & FormatFeatureFlagBits2::eVideoEncodeInputKHR )
|
|
|
1940 result += " VideoEncodeInputKHR |";
|
|
|
1941 if ( value & FormatFeatureFlagBits2::eVideoEncodeDpbKHR )
|
|
|
1942 result += " VideoEncodeDpbKHR |";
|
|
|
1943 if ( value & FormatFeatureFlagBits2::eAccelerationStructureRadiusBufferNV )
|
|
|
1944 result += " AccelerationStructureRadiusBufferNV |";
|
|
|
1945 if ( value & FormatFeatureFlagBits2::eLinearColorAttachmentNV )
|
|
|
1946 result += " LinearColorAttachmentNV |";
|
|
|
1947 if ( value & FormatFeatureFlagBits2::eWeightImageQCOM )
|
|
|
1948 result += " WeightImageQCOM |";
|
|
|
1949 if ( value & FormatFeatureFlagBits2::eWeightSampledImageQCOM )
|
|
|
1950 result += " WeightSampledImageQCOM |";
|
|
|
1951 if ( value & FormatFeatureFlagBits2::eBlockMatchingQCOM )
|
|
|
1952 result += " BlockMatchingQCOM |";
|
|
|
1953 if ( value & FormatFeatureFlagBits2::eBoxFilterSampledQCOM )
|
|
|
1954 result += " BoxFilterSampledQCOM |";
|
|
|
1955 if ( value & FormatFeatureFlagBits2::eTensorShaderARM )
|
|
|
1956 result += " TensorShaderARM |";
|
|
|
1957 if ( value & FormatFeatureFlagBits2::eTensorImageAliasingARM )
|
|
|
1958 result += " TensorImageAliasingARM |";
|
|
|
1959 if ( value & FormatFeatureFlagBits2::eOpticalFlowImageNV )
|
|
|
1960 result += " OpticalFlowImageNV |";
|
|
|
1961 if ( value & FormatFeatureFlagBits2::eOpticalFlowVectorNV )
|
|
|
1962 result += " OpticalFlowVectorNV |";
|
|
|
1963 if ( value & FormatFeatureFlagBits2::eOpticalFlowCostNV )
|
|
|
1964 result += " OpticalFlowCostNV |";
|
|
|
1965 if ( value & FormatFeatureFlagBits2::eTensorDataGraphARM )
|
|
|
1966 result += " TensorDataGraphARM |";
|
|
|
1967 if ( value & FormatFeatureFlagBits2::eCopyImageIndirectDstKHR )
|
|
|
1968 result += " CopyImageIndirectDstKHR |";
|
|
|
1969 if ( value & FormatFeatureFlagBits2::eVideoEncodeQuantizationDeltaMapKHR )
|
|
|
1970 result += " VideoEncodeQuantizationDeltaMapKHR |";
|
|
|
1971 if ( value & FormatFeatureFlagBits2::eVideoEncodeEmphasisMapKHR )
|
|
|
1972 result += " VideoEncodeEmphasisMapKHR |";
|
|
|
1973 if ( value & FormatFeatureFlagBits2::eDepthCopyOnComputeQueueKHR )
|
|
|
1974 result += " DepthCopyOnComputeQueueKHR |";
|
|
|
1975 if ( value & FormatFeatureFlagBits2::eDepthCopyOnTransferQueueKHR )
|
|
|
1976 result += " DepthCopyOnTransferQueueKHR |";
|
|
|
1977 if ( value & FormatFeatureFlagBits2::eStencilCopyOnComputeQueueKHR )
|
|
|
1978 result += " StencilCopyOnComputeQueueKHR |";
|
|
|
1979 if ( value & FormatFeatureFlagBits2::eStencilCopyOnTransferQueueKHR )
|
|
|
1980 result += " StencilCopyOnTransferQueueKHR |";
|
|
|
1981
|
|
|
1982 if ( result.size() > 1 )
|
|
|
1983 result.back() = '}';
|
|
|
1984 else
|
|
|
1985 result = "{}";
|
|
|
1986 return result;
|
|
|
1987 }
|
|
|
1988
|
|
|
1989 VULKAN_HPP_INLINE std::string to_string( PipelineCreationFeedbackFlags value )
|
|
|
1990 {
|
|
|
1991 std::string result = "{";
|
|
|
1992 if ( value & PipelineCreationFeedbackFlagBits::eValid )
|
|
|
1993 result += " Valid |";
|
|
|
1994 if ( value & PipelineCreationFeedbackFlagBits::eApplicationPipelineCacheHit )
|
|
|
1995 result += " ApplicationPipelineCacheHit |";
|
|
|
1996 if ( value & PipelineCreationFeedbackFlagBits::eBasePipelineAcceleration )
|
|
|
1997 result += " BasePipelineAcceleration |";
|
|
|
1998
|
|
|
1999 if ( result.size() > 1 )
|
|
|
2000 result.back() = '}';
|
|
|
2001 else
|
|
|
2002 result = "{}";
|
|
|
2003 return result;
|
|
|
2004 }
|
|
|
2005
|
|
|
2006 VULKAN_HPP_INLINE std::string to_string( RenderingFlags value )
|
|
|
2007 {
|
|
|
2008 std::string result = "{";
|
|
|
2009 if ( value & RenderingFlagBits::eContentsSecondaryCommandBuffers )
|
|
|
2010 result += " ContentsSecondaryCommandBuffers |";
|
|
|
2011 if ( value & RenderingFlagBits::eSuspending )
|
|
|
2012 result += " Suspending |";
|
|
|
2013 if ( value & RenderingFlagBits::eResuming )
|
|
|
2014 result += " Resuming |";
|
|
|
2015 if ( value & RenderingFlagBits::eEnableLegacyDitheringEXT )
|
|
|
2016 result += " EnableLegacyDitheringEXT |";
|
|
|
2017 if ( value & RenderingFlagBits::eContentsInlineKHR )
|
|
|
2018 result += " ContentsInlineKHR |";
|
|
|
2019 if ( value & RenderingFlagBits::ePerLayerFragmentDensityVALVE )
|
|
|
2020 result += " PerLayerFragmentDensityVALVE |";
|
|
|
2021 if ( value & RenderingFlagBits::eFragmentRegionEXT )
|
|
|
2022 result += " FragmentRegionEXT |";
|
|
|
2023 if ( value & RenderingFlagBits::eCustomResolveEXT )
|
|
|
2024 result += " CustomResolveEXT |";
|
|
|
2025 if ( value & RenderingFlagBits::eLocalReadConcurrentAccessControlKHR )
|
|
|
2026 result += " LocalReadConcurrentAccessControlKHR |";
|
|
|
2027
|
|
|
2028 if ( result.size() > 1 )
|
|
|
2029 result.back() = '}';
|
|
|
2030 else
|
|
|
2031 result = "{}";
|
|
|
2032 return result;
|
|
|
2033 }
|
|
|
2034
|
|
|
2035 //=== VK_VERSION_1_4 ===
|
|
|
2036
|
|
|
2037 VULKAN_HPP_INLINE std::string to_string( MemoryUnmapFlags value )
|
|
|
2038 {
|
|
|
2039 std::string result = "{";
|
|
|
2040 if ( value & MemoryUnmapFlagBits::eReserveEXT )
|
|
|
2041 result += " ReserveEXT |";
|
|
|
2042
|
|
|
2043 if ( result.size() > 1 )
|
|
|
2044 result.back() = '}';
|
|
|
2045 else
|
|
|
2046 result = "{}";
|
|
|
2047 return result;
|
|
|
2048 }
|
|
|
2049
|
|
|
2050 VULKAN_HPP_INLINE std::string to_string( BufferUsageFlags2 value )
|
|
|
2051 {
|
|
|
2052 std::string result = "{";
|
|
|
2053 if ( value & BufferUsageFlagBits2::eTransferSrc )
|
|
|
2054 result += " TransferSrc |";
|
|
|
2055 if ( value & BufferUsageFlagBits2::eTransferDst )
|
|
|
2056 result += " TransferDst |";
|
|
|
2057 if ( value & BufferUsageFlagBits2::eUniformTexelBuffer )
|
|
|
2058 result += " UniformTexelBuffer |";
|
|
|
2059 if ( value & BufferUsageFlagBits2::eStorageTexelBuffer )
|
|
|
2060 result += " StorageTexelBuffer |";
|
|
|
2061 if ( value & BufferUsageFlagBits2::eUniformBuffer )
|
|
|
2062 result += " UniformBuffer |";
|
|
|
2063 if ( value & BufferUsageFlagBits2::eStorageBuffer )
|
|
|
2064 result += " StorageBuffer |";
|
|
|
2065 if ( value & BufferUsageFlagBits2::eIndexBuffer )
|
|
|
2066 result += " IndexBuffer |";
|
|
|
2067 if ( value & BufferUsageFlagBits2::eVertexBuffer )
|
|
|
2068 result += " VertexBuffer |";
|
|
|
2069 if ( value & BufferUsageFlagBits2::eIndirectBuffer )
|
|
|
2070 result += " IndirectBuffer |";
|
|
|
2071 if ( value & BufferUsageFlagBits2::eShaderDeviceAddress )
|
|
|
2072 result += " ShaderDeviceAddress |";
|
|
|
2073 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
2074 if ( value & BufferUsageFlagBits2::eExecutionGraphScratchAMDX )
|
|
|
2075 result += " ExecutionGraphScratchAMDX |";
|
|
|
2076 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
2077 if ( value & BufferUsageFlagBits2::eConditionalRenderingEXT )
|
|
|
2078 result += " ConditionalRenderingEXT |";
|
|
|
2079 if ( value & BufferUsageFlagBits2::eShaderBindingTableKHR )
|
|
|
2080 result += " ShaderBindingTableKHR |";
|
|
|
2081 if ( value & BufferUsageFlagBits2::eTransformFeedbackBufferEXT )
|
|
|
2082 result += " TransformFeedbackBufferEXT |";
|
|
|
2083 if ( value & BufferUsageFlagBits2::eTransformFeedbackCounterBufferEXT )
|
|
|
2084 result += " TransformFeedbackCounterBufferEXT |";
|
|
|
2085 if ( value & BufferUsageFlagBits2::eVideoDecodeSrcKHR )
|
|
|
2086 result += " VideoDecodeSrcKHR |";
|
|
|
2087 if ( value & BufferUsageFlagBits2::eVideoDecodeDstKHR )
|
|
|
2088 result += " VideoDecodeDstKHR |";
|
|
|
2089 if ( value & BufferUsageFlagBits2::eVideoEncodeDstKHR )
|
|
|
2090 result += " VideoEncodeDstKHR |";
|
|
|
2091 if ( value & BufferUsageFlagBits2::eVideoEncodeSrcKHR )
|
|
|
2092 result += " VideoEncodeSrcKHR |";
|
|
|
2093 if ( value & BufferUsageFlagBits2::eAccelerationStructureBuildInputReadOnlyKHR )
|
|
|
2094 result += " AccelerationStructureBuildInputReadOnlyKHR |";
|
|
|
2095 if ( value & BufferUsageFlagBits2::eAccelerationStructureStorageKHR )
|
|
|
2096 result += " AccelerationStructureStorageKHR |";
|
|
|
2097 if ( value & BufferUsageFlagBits2::eSamplerDescriptorBufferEXT )
|
|
|
2098 result += " SamplerDescriptorBufferEXT |";
|
|
|
2099 if ( value & BufferUsageFlagBits2::eResourceDescriptorBufferEXT )
|
|
|
2100 result += " ResourceDescriptorBufferEXT |";
|
|
|
2101 if ( value & BufferUsageFlagBits2::ePushDescriptorsDescriptorBufferEXT )
|
|
|
2102 result += " PushDescriptorsDescriptorBufferEXT |";
|
|
|
2103 if ( value & BufferUsageFlagBits2::eMicromapBuildInputReadOnlyEXT )
|
|
|
2104 result += " MicromapBuildInputReadOnlyEXT |";
|
|
|
2105 if ( value & BufferUsageFlagBits2::eMicromapStorageEXT )
|
|
|
2106 result += " MicromapStorageEXT |";
|
|
|
2107 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
2108 if ( value & BufferUsageFlagBits2::eCompressedDataDgf1AMDX )
|
|
|
2109 result += " CompressedDataDgf1AMDX |";
|
|
|
2110 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
2111 if ( value & BufferUsageFlagBits2::eDataGraphForeignDescriptorARM )
|
|
|
2112 result += " DataGraphForeignDescriptorARM |";
|
|
|
2113 if ( value & BufferUsageFlagBits2::eTileMemoryQCOM )
|
|
|
2114 result += " TileMemoryQCOM |";
|
|
|
2115 if ( value & BufferUsageFlagBits2::eMemoryDecompressionEXT )
|
|
|
2116 result += " MemoryDecompressionEXT |";
|
|
|
2117 if ( value & BufferUsageFlagBits2::ePreprocessBufferEXT )
|
|
|
2118 result += " PreprocessBufferEXT |";
|
|
|
2119
|
|
|
2120 if ( result.size() > 1 )
|
|
|
2121 result.back() = '}';
|
|
|
2122 else
|
|
|
2123 result = "{}";
|
|
|
2124 return result;
|
|
|
2125 }
|
|
|
2126
|
|
|
2127 VULKAN_HPP_INLINE std::string to_string( HostImageCopyFlags value )
|
|
|
2128 {
|
|
|
2129 std::string result = "{";
|
|
|
2130 if ( value & HostImageCopyFlagBits::eMemcpy )
|
|
|
2131 result += " Memcpy |";
|
|
|
2132
|
|
|
2133 if ( result.size() > 1 )
|
|
|
2134 result.back() = '}';
|
|
|
2135 else
|
|
|
2136 result = "{}";
|
|
|
2137 return result;
|
|
|
2138 }
|
|
|
2139
|
|
|
2140 VULKAN_HPP_INLINE std::string to_string( PipelineCreateFlags2 value )
|
|
|
2141 {
|
|
|
2142 std::string result = "{";
|
|
|
2143 if ( value & PipelineCreateFlagBits2::eDisableOptimization )
|
|
|
2144 result += " DisableOptimization |";
|
|
|
2145 if ( value & PipelineCreateFlagBits2::eAllowDerivatives )
|
|
|
2146 result += " AllowDerivatives |";
|
|
|
2147 if ( value & PipelineCreateFlagBits2::eDerivative )
|
|
|
2148 result += " Derivative |";
|
|
|
2149 if ( value & PipelineCreateFlagBits2::eViewIndexFromDeviceIndex )
|
|
|
2150 result += " ViewIndexFromDeviceIndex |";
|
|
|
2151 if ( value & PipelineCreateFlagBits2::eDispatchBase )
|
|
|
2152 result += " DispatchBase |";
|
|
|
2153 if ( value & PipelineCreateFlagBits2::eFailOnPipelineCompileRequired )
|
|
|
2154 result += " FailOnPipelineCompileRequired |";
|
|
|
2155 if ( value & PipelineCreateFlagBits2::eEarlyReturnOnFailure )
|
|
|
2156 result += " EarlyReturnOnFailure |";
|
|
|
2157 if ( value & PipelineCreateFlagBits2::eNoProtectedAccess )
|
|
|
2158 result += " NoProtectedAccess |";
|
|
|
2159 if ( value & PipelineCreateFlagBits2::eProtectedAccessOnly )
|
|
|
2160 result += " ProtectedAccessOnly |";
|
|
|
2161 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
2162 if ( value & PipelineCreateFlagBits2::eExecutionGraphAMDX )
|
|
|
2163 result += " ExecutionGraphAMDX |";
|
|
|
2164 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
2165 if ( value & PipelineCreateFlagBits2::eRayTracingAllowSpheresAndLinearSweptSpheresNV )
|
|
|
2166 result += " RayTracingAllowSpheresAndLinearSweptSpheresNV |";
|
|
|
2167 if ( value & PipelineCreateFlagBits2::eEnableLegacyDitheringEXT )
|
|
|
2168 result += " EnableLegacyDitheringEXT |";
|
|
|
2169 if ( value & PipelineCreateFlagBits2::eDeferCompileNV )
|
|
|
2170 result += " DeferCompileNV |";
|
|
|
2171 if ( value & PipelineCreateFlagBits2::eCaptureStatisticsKHR )
|
|
|
2172 result += " CaptureStatisticsKHR |";
|
|
|
2173 if ( value & PipelineCreateFlagBits2::eCaptureInternalRepresentationsKHR )
|
|
|
2174 result += " CaptureInternalRepresentationsKHR |";
|
|
|
2175 if ( value & PipelineCreateFlagBits2::eLinkTimeOptimizationEXT )
|
|
|
2176 result += " LinkTimeOptimizationEXT |";
|
|
|
2177 if ( value & PipelineCreateFlagBits2::eRetainLinkTimeOptimizationInfoEXT )
|
|
|
2178 result += " RetainLinkTimeOptimizationInfoEXT |";
|
|
|
2179 if ( value & PipelineCreateFlagBits2::eLibraryKHR )
|
|
|
2180 result += " LibraryKHR |";
|
|
|
2181 if ( value & PipelineCreateFlagBits2::eRayTracingSkipTrianglesKHR )
|
|
|
2182 result += " RayTracingSkipTrianglesKHR |";
|
|
|
2183 if ( value & PipelineCreateFlagBits2::eRayTracingSkipAabbsKHR )
|
|
|
2184 result += " RayTracingSkipAabbsKHR |";
|
|
|
2185 if ( value & PipelineCreateFlagBits2::eRayTracingNoNullAnyHitShadersKHR )
|
|
|
2186 result += " RayTracingNoNullAnyHitShadersKHR |";
|
|
|
2187 if ( value & PipelineCreateFlagBits2::eRayTracingNoNullClosestHitShadersKHR )
|
|
|
2188 result += " RayTracingNoNullClosestHitShadersKHR |";
|
|
|
2189 if ( value & PipelineCreateFlagBits2::eRayTracingNoNullMissShadersKHR )
|
|
|
2190 result += " RayTracingNoNullMissShadersKHR |";
|
|
|
2191 if ( value & PipelineCreateFlagBits2::eRayTracingNoNullIntersectionShadersKHR )
|
|
|
2192 result += " RayTracingNoNullIntersectionShadersKHR |";
|
|
|
2193 if ( value & PipelineCreateFlagBits2::eRayTracingShaderGroupHandleCaptureReplayKHR )
|
|
|
2194 result += " RayTracingShaderGroupHandleCaptureReplayKHR |";
|
|
|
2195 if ( value & PipelineCreateFlagBits2::eIndirectBindableNV )
|
|
|
2196 result += " IndirectBindableNV |";
|
|
|
2197 if ( value & PipelineCreateFlagBits2::eRayTracingAllowMotionNV )
|
|
|
2198 result += " RayTracingAllowMotionNV |";
|
|
|
2199 if ( value & PipelineCreateFlagBits2::eRenderingFragmentShadingRateAttachmentKHR )
|
|
|
2200 result += " RenderingFragmentShadingRateAttachmentKHR |";
|
|
|
2201 if ( value & PipelineCreateFlagBits2::eRenderingFragmentDensityMapAttachmentEXT )
|
|
|
2202 result += " RenderingFragmentDensityMapAttachmentEXT |";
|
|
|
2203 if ( value & PipelineCreateFlagBits2::eRayTracingOpacityMicromapEXT )
|
|
|
2204 result += " RayTracingOpacityMicromapEXT |";
|
|
|
2205 if ( value & PipelineCreateFlagBits2::eColorAttachmentFeedbackLoopEXT )
|
|
|
2206 result += " ColorAttachmentFeedbackLoopEXT |";
|
|
|
2207 if ( value & PipelineCreateFlagBits2::eDepthStencilAttachmentFeedbackLoopEXT )
|
|
|
2208 result += " DepthStencilAttachmentFeedbackLoopEXT |";
|
|
|
2209 if ( value & PipelineCreateFlagBits2::eRayTracingDisplacementMicromapNV )
|
|
|
2210 result += " RayTracingDisplacementMicromapNV |";
|
|
|
2211 if ( value & PipelineCreateFlagBits2::eDescriptorBufferEXT )
|
|
|
2212 result += " DescriptorBufferEXT |";
|
|
|
2213 if ( value & PipelineCreateFlagBits2::eDisallowOpacityMicromapARM )
|
|
|
2214 result += " DisallowOpacityMicromapARM |";
|
|
|
2215 if ( value & PipelineCreateFlagBits2::eCaptureDataKHR )
|
|
|
2216 result += " CaptureDataKHR |";
|
|
|
2217 if ( value & PipelineCreateFlagBits2::eIndirectBindableEXT )
|
|
|
2218 result += " IndirectBindableEXT |";
|
|
|
2219 if ( value & PipelineCreateFlagBits2::ePerLayerFragmentDensityVALVE )
|
|
|
2220 result += " PerLayerFragmentDensityVALVE |";
|
|
|
2221 if ( value & PipelineCreateFlagBits2::e64BitIndexingEXT )
|
|
|
2222 result += " 64BitIndexingEXT |";
|
|
|
2223
|
|
|
2224 if ( result.size() > 1 )
|
|
|
2225 result.back() = '}';
|
|
|
2226 else
|
|
|
2227 result = "{}";
|
|
|
2228 return result;
|
|
|
2229 }
|
|
|
2230
|
|
|
2231 //=== VK_KHR_surface ===
|
|
|
2232
|
|
|
2233 VULKAN_HPP_INLINE std::string to_string( CompositeAlphaFlagsKHR value )
|
|
|
2234 {
|
|
|
2235 std::string result = "{";
|
|
|
2236 if ( value & CompositeAlphaFlagBitsKHR::eOpaque )
|
|
|
2237 result += " Opaque |";
|
|
|
2238 if ( value & CompositeAlphaFlagBitsKHR::ePreMultiplied )
|
|
|
2239 result += " PreMultiplied |";
|
|
|
2240 if ( value & CompositeAlphaFlagBitsKHR::ePostMultiplied )
|
|
|
2241 result += " PostMultiplied |";
|
|
|
2242 if ( value & CompositeAlphaFlagBitsKHR::eInherit )
|
|
|
2243 result += " Inherit |";
|
|
|
2244
|
|
|
2245 if ( result.size() > 1 )
|
|
|
2246 result.back() = '}';
|
|
|
2247 else
|
|
|
2248 result = "{}";
|
|
|
2249 return result;
|
|
|
2250 }
|
|
|
2251
|
|
|
2252 //=== VK_KHR_swapchain ===
|
|
|
2253
|
|
|
2254 VULKAN_HPP_INLINE std::string to_string( SwapchainCreateFlagsKHR value )
|
|
|
2255 {
|
|
|
2256 std::string result = "{";
|
|
|
2257 if ( value & SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions )
|
|
|
2258 result += " SplitInstanceBindRegions |";
|
|
|
2259 if ( value & SwapchainCreateFlagBitsKHR::eProtected )
|
|
|
2260 result += " Protected |";
|
|
|
2261 if ( value & SwapchainCreateFlagBitsKHR::eMutableFormat )
|
|
|
2262 result += " MutableFormat |";
|
|
|
2263 if ( value & SwapchainCreateFlagBitsKHR::ePresentId2 )
|
|
|
2264 result += " PresentId2 |";
|
|
|
2265 if ( value & SwapchainCreateFlagBitsKHR::ePresentWait2 )
|
|
|
2266 result += " PresentWait2 |";
|
|
|
2267 if ( value & SwapchainCreateFlagBitsKHR::eDeferredMemoryAllocation )
|
|
|
2268 result += " DeferredMemoryAllocation |";
|
|
|
2269
|
|
|
2270 if ( result.size() > 1 )
|
|
|
2271 result.back() = '}';
|
|
|
2272 else
|
|
|
2273 result = "{}";
|
|
|
2274 return result;
|
|
|
2275 }
|
|
|
2276
|
|
|
2277 VULKAN_HPP_INLINE std::string to_string( DeviceGroupPresentModeFlagsKHR value )
|
|
|
2278 {
|
|
|
2279 std::string result = "{";
|
|
|
2280 if ( value & DeviceGroupPresentModeFlagBitsKHR::eLocal )
|
|
|
2281 result += " Local |";
|
|
|
2282 if ( value & DeviceGroupPresentModeFlagBitsKHR::eRemote )
|
|
|
2283 result += " Remote |";
|
|
|
2284 if ( value & DeviceGroupPresentModeFlagBitsKHR::eSum )
|
|
|
2285 result += " Sum |";
|
|
|
2286 if ( value & DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice )
|
|
|
2287 result += " LocalMultiDevice |";
|
|
|
2288
|
|
|
2289 if ( result.size() > 1 )
|
|
|
2290 result.back() = '}';
|
|
|
2291 else
|
|
|
2292 result = "{}";
|
|
|
2293 return result;
|
|
|
2294 }
|
|
|
2295
|
|
|
2296 //=== VK_KHR_display ===
|
|
|
2297
|
|
|
2298 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DisplayModeCreateFlagsKHR )
|
|
|
2299 {
|
|
|
2300 return "{}";
|
|
|
2301 }
|
|
|
2302
|
|
|
2303 VULKAN_HPP_INLINE std::string to_string( DisplayPlaneAlphaFlagsKHR value )
|
|
|
2304 {
|
|
|
2305 std::string result = "{";
|
|
|
2306 if ( value & DisplayPlaneAlphaFlagBitsKHR::eOpaque )
|
|
|
2307 result += " Opaque |";
|
|
|
2308 if ( value & DisplayPlaneAlphaFlagBitsKHR::eGlobal )
|
|
|
2309 result += " Global |";
|
|
|
2310 if ( value & DisplayPlaneAlphaFlagBitsKHR::ePerPixel )
|
|
|
2311 result += " PerPixel |";
|
|
|
2312 if ( value & DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied )
|
|
|
2313 result += " PerPixelPremultiplied |";
|
|
|
2314
|
|
|
2315 if ( result.size() > 1 )
|
|
|
2316 result.back() = '}';
|
|
|
2317 else
|
|
|
2318 result = "{}";
|
|
|
2319 return result;
|
|
|
2320 }
|
|
|
2321
|
|
|
2322 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DisplaySurfaceCreateFlagsKHR )
|
|
|
2323 {
|
|
|
2324 return "{}";
|
|
|
2325 }
|
|
|
2326
|
|
|
2327 VULKAN_HPP_INLINE std::string to_string( SurfaceTransformFlagsKHR value )
|
|
|
2328 {
|
|
|
2329 std::string result = "{";
|
|
|
2330 if ( value & SurfaceTransformFlagBitsKHR::eIdentity )
|
|
|
2331 result += " Identity |";
|
|
|
2332 if ( value & SurfaceTransformFlagBitsKHR::eRotate90 )
|
|
|
2333 result += " Rotate90 |";
|
|
|
2334 if ( value & SurfaceTransformFlagBitsKHR::eRotate180 )
|
|
|
2335 result += " Rotate180 |";
|
|
|
2336 if ( value & SurfaceTransformFlagBitsKHR::eRotate270 )
|
|
|
2337 result += " Rotate270 |";
|
|
|
2338 if ( value & SurfaceTransformFlagBitsKHR::eHorizontalMirror )
|
|
|
2339 result += " HorizontalMirror |";
|
|
|
2340 if ( value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90 )
|
|
|
2341 result += " HorizontalMirrorRotate90 |";
|
|
|
2342 if ( value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180 )
|
|
|
2343 result += " HorizontalMirrorRotate180 |";
|
|
|
2344 if ( value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270 )
|
|
|
2345 result += " HorizontalMirrorRotate270 |";
|
|
|
2346 if ( value & SurfaceTransformFlagBitsKHR::eInherit )
|
|
|
2347 result += " Inherit |";
|
|
|
2348
|
|
|
2349 if ( result.size() > 1 )
|
|
|
2350 result.back() = '}';
|
|
|
2351 else
|
|
|
2352 result = "{}";
|
|
|
2353 return result;
|
|
|
2354 }
|
|
|
2355
|
|
|
2356 #if defined( VK_USE_PLATFORM_XLIB_KHR )
|
|
|
2357 //=== VK_KHR_xlib_surface ===
|
|
|
2358
|
|
|
2359 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( XlibSurfaceCreateFlagsKHR )
|
|
|
2360 {
|
|
|
2361 return "{}";
|
|
|
2362 }
|
|
|
2363 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
|
|
|
2364
|
|
|
2365 #if defined( VK_USE_PLATFORM_XCB_KHR )
|
|
|
2366 //=== VK_KHR_xcb_surface ===
|
|
|
2367
|
|
|
2368 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( XcbSurfaceCreateFlagsKHR )
|
|
|
2369 {
|
|
|
2370 return "{}";
|
|
|
2371 }
|
|
|
2372 #endif /*VK_USE_PLATFORM_XCB_KHR*/
|
|
|
2373
|
|
|
2374 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
|
|
|
2375 //=== VK_KHR_wayland_surface ===
|
|
|
2376
|
|
|
2377 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( WaylandSurfaceCreateFlagsKHR )
|
|
|
2378 {
|
|
|
2379 return "{}";
|
|
|
2380 }
|
|
|
2381 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
|
|
|
2382
|
|
|
2383 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
|
2384 //=== VK_KHR_android_surface ===
|
|
|
2385
|
|
|
2386 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AndroidSurfaceCreateFlagsKHR )
|
|
|
2387 {
|
|
|
2388 return "{}";
|
|
|
2389 }
|
|
|
2390 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
2391
|
|
|
2392 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
2393 //=== VK_KHR_win32_surface ===
|
|
|
2394
|
|
|
2395 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( Win32SurfaceCreateFlagsKHR )
|
|
|
2396 {
|
|
|
2397 return "{}";
|
|
|
2398 }
|
|
|
2399 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
2400
|
|
|
2401 //=== VK_EXT_debug_report ===
|
|
|
2402
|
|
|
2403 VULKAN_HPP_INLINE std::string to_string( DebugReportFlagsEXT value )
|
|
|
2404 {
|
|
|
2405 std::string result = "{";
|
|
|
2406 if ( value & DebugReportFlagBitsEXT::eInformation )
|
|
|
2407 result += " Information |";
|
|
|
2408 if ( value & DebugReportFlagBitsEXT::eWarning )
|
|
|
2409 result += " Warning |";
|
|
|
2410 if ( value & DebugReportFlagBitsEXT::ePerformanceWarning )
|
|
|
2411 result += " PerformanceWarning |";
|
|
|
2412 if ( value & DebugReportFlagBitsEXT::eError )
|
|
|
2413 result += " Error |";
|
|
|
2414 if ( value & DebugReportFlagBitsEXT::eDebug )
|
|
|
2415 result += " Debug |";
|
|
|
2416
|
|
|
2417 if ( result.size() > 1 )
|
|
|
2418 result.back() = '}';
|
|
|
2419 else
|
|
|
2420 result = "{}";
|
|
|
2421 return result;
|
|
|
2422 }
|
|
|
2423
|
|
|
2424 //=== VK_KHR_video_queue ===
|
|
|
2425
|
|
|
2426 VULKAN_HPP_INLINE std::string to_string( VideoCodecOperationFlagsKHR value )
|
|
|
2427 {
|
|
|
2428 std::string result = "{";
|
|
|
2429 if ( value & VideoCodecOperationFlagBitsKHR::eEncodeH264 )
|
|
|
2430 result += " EncodeH264 |";
|
|
|
2431 if ( value & VideoCodecOperationFlagBitsKHR::eEncodeH265 )
|
|
|
2432 result += " EncodeH265 |";
|
|
|
2433 if ( value & VideoCodecOperationFlagBitsKHR::eDecodeH264 )
|
|
|
2434 result += " DecodeH264 |";
|
|
|
2435 if ( value & VideoCodecOperationFlagBitsKHR::eDecodeH265 )
|
|
|
2436 result += " DecodeH265 |";
|
|
|
2437 if ( value & VideoCodecOperationFlagBitsKHR::eDecodeAv1 )
|
|
|
2438 result += " DecodeAv1 |";
|
|
|
2439 if ( value & VideoCodecOperationFlagBitsKHR::eEncodeAv1 )
|
|
|
2440 result += " EncodeAv1 |";
|
|
|
2441 if ( value & VideoCodecOperationFlagBitsKHR::eDecodeVp9 )
|
|
|
2442 result += " DecodeVp9 |";
|
|
|
2443
|
|
|
2444 if ( result.size() > 1 )
|
|
|
2445 result.back() = '}';
|
|
|
2446 else
|
|
|
2447 result = "None";
|
|
|
2448 return result;
|
|
|
2449 }
|
|
|
2450
|
|
|
2451 VULKAN_HPP_INLINE std::string to_string( VideoChromaSubsamplingFlagsKHR value )
|
|
|
2452 {
|
|
|
2453 std::string result = "{";
|
|
|
2454 if ( value & VideoChromaSubsamplingFlagBitsKHR::eMonochrome )
|
|
|
2455 result += " Monochrome |";
|
|
|
2456 if ( value & VideoChromaSubsamplingFlagBitsKHR::e420 )
|
|
|
2457 result += " 420 |";
|
|
|
2458 if ( value & VideoChromaSubsamplingFlagBitsKHR::e422 )
|
|
|
2459 result += " 422 |";
|
|
|
2460 if ( value & VideoChromaSubsamplingFlagBitsKHR::e444 )
|
|
|
2461 result += " 444 |";
|
|
|
2462
|
|
|
2463 if ( result.size() > 1 )
|
|
|
2464 result.back() = '}';
|
|
|
2465 else
|
|
|
2466 result = "Invalid";
|
|
|
2467 return result;
|
|
|
2468 }
|
|
|
2469
|
|
|
2470 VULKAN_HPP_INLINE std::string to_string( VideoComponentBitDepthFlagsKHR value )
|
|
|
2471 {
|
|
|
2472 std::string result = "{";
|
|
|
2473 if ( value & VideoComponentBitDepthFlagBitsKHR::e8 )
|
|
|
2474 result += " 8 |";
|
|
|
2475 if ( value & VideoComponentBitDepthFlagBitsKHR::e10 )
|
|
|
2476 result += " 10 |";
|
|
|
2477 if ( value & VideoComponentBitDepthFlagBitsKHR::e12 )
|
|
|
2478 result += " 12 |";
|
|
|
2479
|
|
|
2480 if ( result.size() > 1 )
|
|
|
2481 result.back() = '}';
|
|
|
2482 else
|
|
|
2483 result = "Invalid";
|
|
|
2484 return result;
|
|
|
2485 }
|
|
|
2486
|
|
|
2487 VULKAN_HPP_INLINE std::string to_string( VideoCapabilityFlagsKHR value )
|
|
|
2488 {
|
|
|
2489 std::string result = "{";
|
|
|
2490 if ( value & VideoCapabilityFlagBitsKHR::eProtectedContent )
|
|
|
2491 result += " ProtectedContent |";
|
|
|
2492 if ( value & VideoCapabilityFlagBitsKHR::eSeparateReferenceImages )
|
|
|
2493 result += " SeparateReferenceImages |";
|
|
|
2494
|
|
|
2495 if ( result.size() > 1 )
|
|
|
2496 result.back() = '}';
|
|
|
2497 else
|
|
|
2498 result = "{}";
|
|
|
2499 return result;
|
|
|
2500 }
|
|
|
2501
|
|
|
2502 VULKAN_HPP_INLINE std::string to_string( VideoSessionCreateFlagsKHR value )
|
|
|
2503 {
|
|
|
2504 std::string result = "{";
|
|
|
2505 if ( value & VideoSessionCreateFlagBitsKHR::eProtectedContent )
|
|
|
2506 result += " ProtectedContent |";
|
|
|
2507 if ( value & VideoSessionCreateFlagBitsKHR::eAllowEncodeParameterOptimizations )
|
|
|
2508 result += " AllowEncodeParameterOptimizations |";
|
|
|
2509 if ( value & VideoSessionCreateFlagBitsKHR::eInlineQueries )
|
|
|
2510 result += " InlineQueries |";
|
|
|
2511 if ( value & VideoSessionCreateFlagBitsKHR::eAllowEncodeQuantizationDeltaMap )
|
|
|
2512 result += " AllowEncodeQuantizationDeltaMap |";
|
|
|
2513 if ( value & VideoSessionCreateFlagBitsKHR::eAllowEncodeEmphasisMap )
|
|
|
2514 result += " AllowEncodeEmphasisMap |";
|
|
|
2515 if ( value & VideoSessionCreateFlagBitsKHR::eInlineSessionParameters )
|
|
|
2516 result += " InlineSessionParameters |";
|
|
|
2517
|
|
|
2518 if ( result.size() > 1 )
|
|
|
2519 result.back() = '}';
|
|
|
2520 else
|
|
|
2521 result = "{}";
|
|
|
2522 return result;
|
|
|
2523 }
|
|
|
2524
|
|
|
2525 VULKAN_HPP_INLINE std::string to_string( VideoSessionParametersCreateFlagsKHR value )
|
|
|
2526 {
|
|
|
2527 std::string result = "{";
|
|
|
2528 if ( value & VideoSessionParametersCreateFlagBitsKHR::eQuantizationMapCompatible )
|
|
|
2529 result += " QuantizationMapCompatible |";
|
|
|
2530
|
|
|
2531 if ( result.size() > 1 )
|
|
|
2532 result.back() = '}';
|
|
|
2533 else
|
|
|
2534 result = "{}";
|
|
|
2535 return result;
|
|
|
2536 }
|
|
|
2537
|
|
|
2538 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoBeginCodingFlagsKHR )
|
|
|
2539 {
|
|
|
2540 return "{}";
|
|
|
2541 }
|
|
|
2542
|
|
|
2543 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEndCodingFlagsKHR )
|
|
|
2544 {
|
|
|
2545 return "{}";
|
|
|
2546 }
|
|
|
2547
|
|
|
2548 VULKAN_HPP_INLINE std::string to_string( VideoCodingControlFlagsKHR value )
|
|
|
2549 {
|
|
|
2550 std::string result = "{";
|
|
|
2551 if ( value & VideoCodingControlFlagBitsKHR::eReset )
|
|
|
2552 result += " Reset |";
|
|
|
2553 if ( value & VideoCodingControlFlagBitsKHR::eEncodeRateControl )
|
|
|
2554 result += " EncodeRateControl |";
|
|
|
2555 if ( value & VideoCodingControlFlagBitsKHR::eEncodeQualityLevel )
|
|
|
2556 result += " EncodeQualityLevel |";
|
|
|
2557
|
|
|
2558 if ( result.size() > 1 )
|
|
|
2559 result.back() = '}';
|
|
|
2560 else
|
|
|
2561 result = "{}";
|
|
|
2562 return result;
|
|
|
2563 }
|
|
|
2564
|
|
|
2565 //=== VK_KHR_video_decode_queue ===
|
|
|
2566
|
|
|
2567 VULKAN_HPP_INLINE std::string to_string( VideoDecodeCapabilityFlagsKHR value )
|
|
|
2568 {
|
|
|
2569 std::string result = "{";
|
|
|
2570 if ( value & VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputCoincide )
|
|
|
2571 result += " DpbAndOutputCoincide |";
|
|
|
2572 if ( value & VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputDistinct )
|
|
|
2573 result += " DpbAndOutputDistinct |";
|
|
|
2574
|
|
|
2575 if ( result.size() > 1 )
|
|
|
2576 result.back() = '}';
|
|
|
2577 else
|
|
|
2578 result = "{}";
|
|
|
2579 return result;
|
|
|
2580 }
|
|
|
2581
|
|
|
2582 VULKAN_HPP_INLINE std::string to_string( VideoDecodeUsageFlagsKHR value )
|
|
|
2583 {
|
|
|
2584 std::string result = "{";
|
|
|
2585 if ( value & VideoDecodeUsageFlagBitsKHR::eTranscoding )
|
|
|
2586 result += " Transcoding |";
|
|
|
2587 if ( value & VideoDecodeUsageFlagBitsKHR::eOffline )
|
|
|
2588 result += " Offline |";
|
|
|
2589 if ( value & VideoDecodeUsageFlagBitsKHR::eStreaming )
|
|
|
2590 result += " Streaming |";
|
|
|
2591
|
|
|
2592 if ( result.size() > 1 )
|
|
|
2593 result.back() = '}';
|
|
|
2594 else
|
|
|
2595 result = "Default";
|
|
|
2596 return result;
|
|
|
2597 }
|
|
|
2598
|
|
|
2599 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoDecodeFlagsKHR )
|
|
|
2600 {
|
|
|
2601 return "{}";
|
|
|
2602 }
|
|
|
2603
|
|
|
2604 //=== VK_EXT_transform_feedback ===
|
|
|
2605
|
|
|
2606 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRasterizationStateStreamCreateFlagsEXT )
|
|
|
2607 {
|
|
|
2608 return "{}";
|
|
|
2609 }
|
|
|
2610
|
|
|
2611 //=== VK_KHR_video_encode_h264 ===
|
|
|
2612
|
|
|
2613 VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264CapabilityFlagsKHR value )
|
|
|
2614 {
|
|
|
2615 std::string result = "{";
|
|
|
2616 if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eHrdCompliance )
|
|
|
2617 result += " HrdCompliance |";
|
|
|
2618 if ( value & VideoEncodeH264CapabilityFlagBitsKHR::ePredictionWeightTableGenerated )
|
|
|
2619 result += " PredictionWeightTableGenerated |";
|
|
|
2620 if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eRowUnalignedSlice )
|
|
|
2621 result += " RowUnalignedSlice |";
|
|
|
2622 if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eDifferentSliceType )
|
|
|
2623 result += " DifferentSliceType |";
|
|
|
2624 if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eBFrameInL0List )
|
|
|
2625 result += " BFrameInL0List |";
|
|
|
2626 if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eBFrameInL1List )
|
|
|
2627 result += " BFrameInL1List |";
|
|
|
2628 if ( value & VideoEncodeH264CapabilityFlagBitsKHR::ePerPictureTypeMinMaxQp )
|
|
|
2629 result += " PerPictureTypeMinMaxQp |";
|
|
|
2630 if ( value & VideoEncodeH264CapabilityFlagBitsKHR::ePerSliceConstantQp )
|
|
|
2631 result += " PerSliceConstantQp |";
|
|
|
2632 if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eGeneratePrefixNalu )
|
|
|
2633 result += " GeneratePrefixNalu |";
|
|
|
2634 if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eBPictureIntraRefresh )
|
|
|
2635 result += " BPictureIntraRefresh |";
|
|
|
2636 if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eMbQpDiffWraparound )
|
|
|
2637 result += " MbQpDiffWraparound |";
|
|
|
2638
|
|
|
2639 if ( result.size() > 1 )
|
|
|
2640 result.back() = '}';
|
|
|
2641 else
|
|
|
2642 result = "{}";
|
|
|
2643 return result;
|
|
|
2644 }
|
|
|
2645
|
|
|
2646 VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264StdFlagsKHR value )
|
|
|
2647 {
|
|
|
2648 std::string result = "{";
|
|
|
2649 if ( value & VideoEncodeH264StdFlagBitsKHR::eSeparateColorPlaneFlagSet )
|
|
|
2650 result += " SeparateColorPlaneFlagSet |";
|
|
|
2651 if ( value & VideoEncodeH264StdFlagBitsKHR::eQpprimeYZeroTransformBypassFlagSet )
|
|
|
2652 result += " QpprimeYZeroTransformBypassFlagSet |";
|
|
|
2653 if ( value & VideoEncodeH264StdFlagBitsKHR::eScalingMatrixPresentFlagSet )
|
|
|
2654 result += " ScalingMatrixPresentFlagSet |";
|
|
|
2655 if ( value & VideoEncodeH264StdFlagBitsKHR::eChromaQpIndexOffset )
|
|
|
2656 result += " ChromaQpIndexOffset |";
|
|
|
2657 if ( value & VideoEncodeH264StdFlagBitsKHR::eSecondChromaQpIndexOffset )
|
|
|
2658 result += " SecondChromaQpIndexOffset |";
|
|
|
2659 if ( value & VideoEncodeH264StdFlagBitsKHR::ePicInitQpMinus26 )
|
|
|
2660 result += " PicInitQpMinus26 |";
|
|
|
2661 if ( value & VideoEncodeH264StdFlagBitsKHR::eWeightedPredFlagSet )
|
|
|
2662 result += " WeightedPredFlagSet |";
|
|
|
2663 if ( value & VideoEncodeH264StdFlagBitsKHR::eWeightedBipredIdcExplicit )
|
|
|
2664 result += " WeightedBipredIdcExplicit |";
|
|
|
2665 if ( value & VideoEncodeH264StdFlagBitsKHR::eWeightedBipredIdcImplicit )
|
|
|
2666 result += " WeightedBipredIdcImplicit |";
|
|
|
2667 if ( value & VideoEncodeH264StdFlagBitsKHR::eTransform8X8ModeFlagSet )
|
|
|
2668 result += " Transform8X8ModeFlagSet |";
|
|
|
2669 if ( value & VideoEncodeH264StdFlagBitsKHR::eDirectSpatialMvPredFlagUnset )
|
|
|
2670 result += " DirectSpatialMvPredFlagUnset |";
|
|
|
2671 if ( value & VideoEncodeH264StdFlagBitsKHR::eEntropyCodingModeFlagUnset )
|
|
|
2672 result += " EntropyCodingModeFlagUnset |";
|
|
|
2673 if ( value & VideoEncodeH264StdFlagBitsKHR::eEntropyCodingModeFlagSet )
|
|
|
2674 result += " EntropyCodingModeFlagSet |";
|
|
|
2675 if ( value & VideoEncodeH264StdFlagBitsKHR::eDirect8X8InferenceFlagUnset )
|
|
|
2676 result += " Direct8X8InferenceFlagUnset |";
|
|
|
2677 if ( value & VideoEncodeH264StdFlagBitsKHR::eConstrainedIntraPredFlagSet )
|
|
|
2678 result += " ConstrainedIntraPredFlagSet |";
|
|
|
2679 if ( value & VideoEncodeH264StdFlagBitsKHR::eDeblockingFilterDisabled )
|
|
|
2680 result += " DeblockingFilterDisabled |";
|
|
|
2681 if ( value & VideoEncodeH264StdFlagBitsKHR::eDeblockingFilterEnabled )
|
|
|
2682 result += " DeblockingFilterEnabled |";
|
|
|
2683 if ( value & VideoEncodeH264StdFlagBitsKHR::eDeblockingFilterPartial )
|
|
|
2684 result += " DeblockingFilterPartial |";
|
|
|
2685 if ( value & VideoEncodeH264StdFlagBitsKHR::eSliceQpDelta )
|
|
|
2686 result += " SliceQpDelta |";
|
|
|
2687 if ( value & VideoEncodeH264StdFlagBitsKHR::eDifferentSliceQpDelta )
|
|
|
2688 result += " DifferentSliceQpDelta |";
|
|
|
2689
|
|
|
2690 if ( result.size() > 1 )
|
|
|
2691 result.back() = '}';
|
|
|
2692 else
|
|
|
2693 result = "{}";
|
|
|
2694 return result;
|
|
|
2695 }
|
|
|
2696
|
|
|
2697 VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264RateControlFlagsKHR value )
|
|
|
2698 {
|
|
|
2699 std::string result = "{";
|
|
|
2700 if ( value & VideoEncodeH264RateControlFlagBitsKHR::eAttemptHrdCompliance )
|
|
|
2701 result += " AttemptHrdCompliance |";
|
|
|
2702 if ( value & VideoEncodeH264RateControlFlagBitsKHR::eRegularGop )
|
|
|
2703 result += " RegularGop |";
|
|
|
2704 if ( value & VideoEncodeH264RateControlFlagBitsKHR::eReferencePatternFlat )
|
|
|
2705 result += " ReferencePatternFlat |";
|
|
|
2706 if ( value & VideoEncodeH264RateControlFlagBitsKHR::eReferencePatternDyadic )
|
|
|
2707 result += " ReferencePatternDyadic |";
|
|
|
2708 if ( value & VideoEncodeH264RateControlFlagBitsKHR::eTemporalLayerPatternDyadic )
|
|
|
2709 result += " TemporalLayerPatternDyadic |";
|
|
|
2710
|
|
|
2711 if ( result.size() > 1 )
|
|
|
2712 result.back() = '}';
|
|
|
2713 else
|
|
|
2714 result = "{}";
|
|
|
2715 return result;
|
|
|
2716 }
|
|
|
2717
|
|
|
2718 //=== VK_KHR_video_encode_h265 ===
|
|
|
2719
|
|
|
2720 VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265CapabilityFlagsKHR value )
|
|
|
2721 {
|
|
|
2722 std::string result = "{";
|
|
|
2723 if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eHrdCompliance )
|
|
|
2724 result += " HrdCompliance |";
|
|
|
2725 if ( value & VideoEncodeH265CapabilityFlagBitsKHR::ePredictionWeightTableGenerated )
|
|
|
2726 result += " PredictionWeightTableGenerated |";
|
|
|
2727 if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eRowUnalignedSliceSegment )
|
|
|
2728 result += " RowUnalignedSliceSegment |";
|
|
|
2729 if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eDifferentSliceSegmentType )
|
|
|
2730 result += " DifferentSliceSegmentType |";
|
|
|
2731 if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eBFrameInL0List )
|
|
|
2732 result += " BFrameInL0List |";
|
|
|
2733 if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eBFrameInL1List )
|
|
|
2734 result += " BFrameInL1List |";
|
|
|
2735 if ( value & VideoEncodeH265CapabilityFlagBitsKHR::ePerPictureTypeMinMaxQp )
|
|
|
2736 result += " PerPictureTypeMinMaxQp |";
|
|
|
2737 if ( value & VideoEncodeH265CapabilityFlagBitsKHR::ePerSliceSegmentConstantQp )
|
|
|
2738 result += " PerSliceSegmentConstantQp |";
|
|
|
2739 if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eMultipleTilesPerSliceSegment )
|
|
|
2740 result += " MultipleTilesPerSliceSegment |";
|
|
|
2741 if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eMultipleSliceSegmentsPerTile )
|
|
|
2742 result += " MultipleSliceSegmentsPerTile |";
|
|
|
2743 if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eBPictureIntraRefresh )
|
|
|
2744 result += " BPictureIntraRefresh |";
|
|
|
2745 if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eCuQpDiffWraparound )
|
|
|
2746 result += " CuQpDiffWraparound |";
|
|
|
2747
|
|
|
2748 if ( result.size() > 1 )
|
|
|
2749 result.back() = '}';
|
|
|
2750 else
|
|
|
2751 result = "{}";
|
|
|
2752 return result;
|
|
|
2753 }
|
|
|
2754
|
|
|
2755 VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265StdFlagsKHR value )
|
|
|
2756 {
|
|
|
2757 std::string result = "{";
|
|
|
2758 if ( value & VideoEncodeH265StdFlagBitsKHR::eSeparateColorPlaneFlagSet )
|
|
|
2759 result += " SeparateColorPlaneFlagSet |";
|
|
|
2760 if ( value & VideoEncodeH265StdFlagBitsKHR::eSampleAdaptiveOffsetEnabledFlagSet )
|
|
|
2761 result += " SampleAdaptiveOffsetEnabledFlagSet |";
|
|
|
2762 if ( value & VideoEncodeH265StdFlagBitsKHR::eScalingListDataPresentFlagSet )
|
|
|
2763 result += " ScalingListDataPresentFlagSet |";
|
|
|
2764 if ( value & VideoEncodeH265StdFlagBitsKHR::ePcmEnabledFlagSet )
|
|
|
2765 result += " PcmEnabledFlagSet |";
|
|
|
2766 if ( value & VideoEncodeH265StdFlagBitsKHR::eSpsTemporalMvpEnabledFlagSet )
|
|
|
2767 result += " SpsTemporalMvpEnabledFlagSet |";
|
|
|
2768 if ( value & VideoEncodeH265StdFlagBitsKHR::eInitQpMinus26 )
|
|
|
2769 result += " InitQpMinus26 |";
|
|
|
2770 if ( value & VideoEncodeH265StdFlagBitsKHR::eWeightedPredFlagSet )
|
|
|
2771 result += " WeightedPredFlagSet |";
|
|
|
2772 if ( value & VideoEncodeH265StdFlagBitsKHR::eWeightedBipredFlagSet )
|
|
|
2773 result += " WeightedBipredFlagSet |";
|
|
|
2774 if ( value & VideoEncodeH265StdFlagBitsKHR::eLog2ParallelMergeLevelMinus2 )
|
|
|
2775 result += " Log2ParallelMergeLevelMinus2 |";
|
|
|
2776 if ( value & VideoEncodeH265StdFlagBitsKHR::eSignDataHidingEnabledFlagSet )
|
|
|
2777 result += " SignDataHidingEnabledFlagSet |";
|
|
|
2778 if ( value & VideoEncodeH265StdFlagBitsKHR::eTransformSkipEnabledFlagSet )
|
|
|
2779 result += " TransformSkipEnabledFlagSet |";
|
|
|
2780 if ( value & VideoEncodeH265StdFlagBitsKHR::eTransformSkipEnabledFlagUnset )
|
|
|
2781 result += " TransformSkipEnabledFlagUnset |";
|
|
|
2782 if ( value & VideoEncodeH265StdFlagBitsKHR::ePpsSliceChromaQpOffsetsPresentFlagSet )
|
|
|
2783 result += " PpsSliceChromaQpOffsetsPresentFlagSet |";
|
|
|
2784 if ( value & VideoEncodeH265StdFlagBitsKHR::eTransquantBypassEnabledFlagSet )
|
|
|
2785 result += " TransquantBypassEnabledFlagSet |";
|
|
|
2786 if ( value & VideoEncodeH265StdFlagBitsKHR::eConstrainedIntraPredFlagSet )
|
|
|
2787 result += " ConstrainedIntraPredFlagSet |";
|
|
|
2788 if ( value & VideoEncodeH265StdFlagBitsKHR::eEntropyCodingSyncEnabledFlagSet )
|
|
|
2789 result += " EntropyCodingSyncEnabledFlagSet |";
|
|
|
2790 if ( value & VideoEncodeH265StdFlagBitsKHR::eDeblockingFilterOverrideEnabledFlagSet )
|
|
|
2791 result += " DeblockingFilterOverrideEnabledFlagSet |";
|
|
|
2792 if ( value & VideoEncodeH265StdFlagBitsKHR::eDependentSliceSegmentsEnabledFlagSet )
|
|
|
2793 result += " DependentSliceSegmentsEnabledFlagSet |";
|
|
|
2794 if ( value & VideoEncodeH265StdFlagBitsKHR::eDependentSliceSegmentFlagSet )
|
|
|
2795 result += " DependentSliceSegmentFlagSet |";
|
|
|
2796 if ( value & VideoEncodeH265StdFlagBitsKHR::eSliceQpDelta )
|
|
|
2797 result += " SliceQpDelta |";
|
|
|
2798 if ( value & VideoEncodeH265StdFlagBitsKHR::eDifferentSliceQpDelta )
|
|
|
2799 result += " DifferentSliceQpDelta |";
|
|
|
2800
|
|
|
2801 if ( result.size() > 1 )
|
|
|
2802 result.back() = '}';
|
|
|
2803 else
|
|
|
2804 result = "{}";
|
|
|
2805 return result;
|
|
|
2806 }
|
|
|
2807
|
|
|
2808 VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265CtbSizeFlagsKHR value )
|
|
|
2809 {
|
|
|
2810 std::string result = "{";
|
|
|
2811 if ( value & VideoEncodeH265CtbSizeFlagBitsKHR::e16 )
|
|
|
2812 result += " 16 |";
|
|
|
2813 if ( value & VideoEncodeH265CtbSizeFlagBitsKHR::e32 )
|
|
|
2814 result += " 32 |";
|
|
|
2815 if ( value & VideoEncodeH265CtbSizeFlagBitsKHR::e64 )
|
|
|
2816 result += " 64 |";
|
|
|
2817
|
|
|
2818 if ( result.size() > 1 )
|
|
|
2819 result.back() = '}';
|
|
|
2820 else
|
|
|
2821 result = "{}";
|
|
|
2822 return result;
|
|
|
2823 }
|
|
|
2824
|
|
|
2825 VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265TransformBlockSizeFlagsKHR value )
|
|
|
2826 {
|
|
|
2827 std::string result = "{";
|
|
|
2828 if ( value & VideoEncodeH265TransformBlockSizeFlagBitsKHR::e4 )
|
|
|
2829 result += " 4 |";
|
|
|
2830 if ( value & VideoEncodeH265TransformBlockSizeFlagBitsKHR::e8 )
|
|
|
2831 result += " 8 |";
|
|
|
2832 if ( value & VideoEncodeH265TransformBlockSizeFlagBitsKHR::e16 )
|
|
|
2833 result += " 16 |";
|
|
|
2834 if ( value & VideoEncodeH265TransformBlockSizeFlagBitsKHR::e32 )
|
|
|
2835 result += " 32 |";
|
|
|
2836
|
|
|
2837 if ( result.size() > 1 )
|
|
|
2838 result.back() = '}';
|
|
|
2839 else
|
|
|
2840 result = "{}";
|
|
|
2841 return result;
|
|
|
2842 }
|
|
|
2843
|
|
|
2844 VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265RateControlFlagsKHR value )
|
|
|
2845 {
|
|
|
2846 std::string result = "{";
|
|
|
2847 if ( value & VideoEncodeH265RateControlFlagBitsKHR::eAttemptHrdCompliance )
|
|
|
2848 result += " AttemptHrdCompliance |";
|
|
|
2849 if ( value & VideoEncodeH265RateControlFlagBitsKHR::eRegularGop )
|
|
|
2850 result += " RegularGop |";
|
|
|
2851 if ( value & VideoEncodeH265RateControlFlagBitsKHR::eReferencePatternFlat )
|
|
|
2852 result += " ReferencePatternFlat |";
|
|
|
2853 if ( value & VideoEncodeH265RateControlFlagBitsKHR::eReferencePatternDyadic )
|
|
|
2854 result += " ReferencePatternDyadic |";
|
|
|
2855 if ( value & VideoEncodeH265RateControlFlagBitsKHR::eTemporalSubLayerPatternDyadic )
|
|
|
2856 result += " TemporalSubLayerPatternDyadic |";
|
|
|
2857
|
|
|
2858 if ( result.size() > 1 )
|
|
|
2859 result.back() = '}';
|
|
|
2860 else
|
|
|
2861 result = "{}";
|
|
|
2862 return result;
|
|
|
2863 }
|
|
|
2864
|
|
|
2865 //=== VK_KHR_video_decode_h264 ===
|
|
|
2866
|
|
|
2867 VULKAN_HPP_INLINE std::string to_string( VideoDecodeH264PictureLayoutFlagsKHR value )
|
|
|
2868 {
|
|
|
2869 std::string result = "{";
|
|
|
2870 if ( value & VideoDecodeH264PictureLayoutFlagBitsKHR::eInterlacedInterleavedLines )
|
|
|
2871 result += " InterlacedInterleavedLines |";
|
|
|
2872 if ( value & VideoDecodeH264PictureLayoutFlagBitsKHR::eInterlacedSeparatePlanes )
|
|
|
2873 result += " InterlacedSeparatePlanes |";
|
|
|
2874
|
|
|
2875 if ( result.size() > 1 )
|
|
|
2876 result.back() = '}';
|
|
|
2877 else
|
|
|
2878 result = "Progressive";
|
|
|
2879 return result;
|
|
|
2880 }
|
|
|
2881
|
|
|
2882 #if defined( VK_USE_PLATFORM_GGP )
|
|
|
2883 //=== VK_GGP_stream_descriptor_surface ===
|
|
|
2884
|
|
|
2885 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( StreamDescriptorSurfaceCreateFlagsGGP )
|
|
|
2886 {
|
|
|
2887 return "{}";
|
|
|
2888 }
|
|
|
2889 #endif /*VK_USE_PLATFORM_GGP*/
|
|
|
2890
|
|
|
2891 //=== VK_NV_external_memory_capabilities ===
|
|
|
2892
|
|
|
2893 VULKAN_HPP_INLINE std::string to_string( ExternalMemoryHandleTypeFlagsNV value )
|
|
|
2894 {
|
|
|
2895 std::string result = "{";
|
|
|
2896 if ( value & ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32 )
|
|
|
2897 result += " OpaqueWin32 |";
|
|
|
2898 if ( value & ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt )
|
|
|
2899 result += " OpaqueWin32Kmt |";
|
|
|
2900 if ( value & ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image )
|
|
|
2901 result += " D3D11Image |";
|
|
|
2902 if ( value & ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt )
|
|
|
2903 result += " D3D11ImageKmt |";
|
|
|
2904
|
|
|
2905 if ( result.size() > 1 )
|
|
|
2906 result.back() = '}';
|
|
|
2907 else
|
|
|
2908 result = "{}";
|
|
|
2909 return result;
|
|
|
2910 }
|
|
|
2911
|
|
|
2912 VULKAN_HPP_INLINE std::string to_string( ExternalMemoryFeatureFlagsNV value )
|
|
|
2913 {
|
|
|
2914 std::string result = "{";
|
|
|
2915 if ( value & ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly )
|
|
|
2916 result += " DedicatedOnly |";
|
|
|
2917 if ( value & ExternalMemoryFeatureFlagBitsNV::eExportable )
|
|
|
2918 result += " Exportable |";
|
|
|
2919 if ( value & ExternalMemoryFeatureFlagBitsNV::eImportable )
|
|
|
2920 result += " Importable |";
|
|
|
2921
|
|
|
2922 if ( result.size() > 1 )
|
|
|
2923 result.back() = '}';
|
|
|
2924 else
|
|
|
2925 result = "{}";
|
|
|
2926 return result;
|
|
|
2927 }
|
|
|
2928
|
|
|
2929 #if defined( VK_USE_PLATFORM_VI_NN )
|
|
|
2930 //=== VK_NN_vi_surface ===
|
|
|
2931
|
|
|
2932 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ViSurfaceCreateFlagsNN )
|
|
|
2933 {
|
|
|
2934 return "{}";
|
|
|
2935 }
|
|
|
2936 #endif /*VK_USE_PLATFORM_VI_NN*/
|
|
|
2937
|
|
|
2938 //=== VK_EXT_conditional_rendering ===
|
|
|
2939
|
|
|
2940 VULKAN_HPP_INLINE std::string to_string( ConditionalRenderingFlagsEXT value )
|
|
|
2941 {
|
|
|
2942 std::string result = "{";
|
|
|
2943 if ( value & ConditionalRenderingFlagBitsEXT::eInverted )
|
|
|
2944 result += " Inverted |";
|
|
|
2945
|
|
|
2946 if ( result.size() > 1 )
|
|
|
2947 result.back() = '}';
|
|
|
2948 else
|
|
|
2949 result = "{}";
|
|
|
2950 return result;
|
|
|
2951 }
|
|
|
2952
|
|
|
2953 //=== VK_EXT_display_surface_counter ===
|
|
|
2954
|
|
|
2955 VULKAN_HPP_INLINE std::string to_string( SurfaceCounterFlagsEXT value )
|
|
|
2956 {
|
|
|
2957 std::string result = "{";
|
|
|
2958 if ( value & SurfaceCounterFlagBitsEXT::eVblank )
|
|
|
2959 result += " Vblank |";
|
|
|
2960
|
|
|
2961 if ( result.size() > 1 )
|
|
|
2962 result.back() = '}';
|
|
|
2963 else
|
|
|
2964 result = "{}";
|
|
|
2965 return result;
|
|
|
2966 }
|
|
|
2967
|
|
|
2968 //=== VK_NV_viewport_swizzle ===
|
|
|
2969
|
|
|
2970 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineViewportSwizzleStateCreateFlagsNV )
|
|
|
2971 {
|
|
|
2972 return "{}";
|
|
|
2973 }
|
|
|
2974
|
|
|
2975 //=== VK_EXT_discard_rectangles ===
|
|
|
2976
|
|
|
2977 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineDiscardRectangleStateCreateFlagsEXT )
|
|
|
2978 {
|
|
|
2979 return "{}";
|
|
|
2980 }
|
|
|
2981
|
|
|
2982 //=== VK_EXT_conservative_rasterization ===
|
|
|
2983
|
|
|
2984 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRasterizationConservativeStateCreateFlagsEXT )
|
|
|
2985 {
|
|
|
2986 return "{}";
|
|
|
2987 }
|
|
|
2988
|
|
|
2989 //=== VK_EXT_depth_clip_enable ===
|
|
|
2990
|
|
|
2991 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRasterizationDepthClipStateCreateFlagsEXT )
|
|
|
2992 {
|
|
|
2993 return "{}";
|
|
|
2994 }
|
|
|
2995
|
|
|
2996 //=== VK_KHR_performance_query ===
|
|
|
2997
|
|
|
2998 VULKAN_HPP_INLINE std::string to_string( PerformanceCounterDescriptionFlagsKHR value )
|
|
|
2999 {
|
|
|
3000 std::string result = "{";
|
|
|
3001 if ( value & PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting )
|
|
|
3002 result += " PerformanceImpacting |";
|
|
|
3003 if ( value & PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted )
|
|
|
3004 result += " ConcurrentlyImpacted |";
|
|
|
3005
|
|
|
3006 if ( result.size() > 1 )
|
|
|
3007 result.back() = '}';
|
|
|
3008 else
|
|
|
3009 result = "{}";
|
|
|
3010 return result;
|
|
|
3011 }
|
|
|
3012
|
|
|
3013 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AcquireProfilingLockFlagsKHR )
|
|
|
3014 {
|
|
|
3015 return "{}";
|
|
|
3016 }
|
|
|
3017
|
|
|
3018 #if defined( VK_USE_PLATFORM_IOS_MVK )
|
|
|
3019 //=== VK_MVK_ios_surface ===
|
|
|
3020
|
|
|
3021 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IOSSurfaceCreateFlagsMVK )
|
|
|
3022 {
|
|
|
3023 return "{}";
|
|
|
3024 }
|
|
|
3025 #endif /*VK_USE_PLATFORM_IOS_MVK*/
|
|
|
3026
|
|
|
3027 #if defined( VK_USE_PLATFORM_MACOS_MVK )
|
|
|
3028 //=== VK_MVK_macos_surface ===
|
|
|
3029
|
|
|
3030 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MacOSSurfaceCreateFlagsMVK )
|
|
|
3031 {
|
|
|
3032 return "{}";
|
|
|
3033 }
|
|
|
3034 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
|
|
|
3035
|
|
|
3036 //=== VK_EXT_debug_utils ===
|
|
|
3037
|
|
|
3038 VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessageSeverityFlagsEXT value )
|
|
|
3039 {
|
|
|
3040 std::string result = "{";
|
|
|
3041 if ( value & DebugUtilsMessageSeverityFlagBitsEXT::eVerbose )
|
|
|
3042 result += " Verbose |";
|
|
|
3043 if ( value & DebugUtilsMessageSeverityFlagBitsEXT::eInfo )
|
|
|
3044 result += " Info |";
|
|
|
3045 if ( value & DebugUtilsMessageSeverityFlagBitsEXT::eWarning )
|
|
|
3046 result += " Warning |";
|
|
|
3047 if ( value & DebugUtilsMessageSeverityFlagBitsEXT::eError )
|
|
|
3048 result += " Error |";
|
|
|
3049
|
|
|
3050 if ( result.size() > 1 )
|
|
|
3051 result.back() = '}';
|
|
|
3052 else
|
|
|
3053 result = "{}";
|
|
|
3054 return result;
|
|
|
3055 }
|
|
|
3056
|
|
|
3057 VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessageTypeFlagsEXT value )
|
|
|
3058 {
|
|
|
3059 std::string result = "{";
|
|
|
3060 if ( value & DebugUtilsMessageTypeFlagBitsEXT::eGeneral )
|
|
|
3061 result += " General |";
|
|
|
3062 if ( value & DebugUtilsMessageTypeFlagBitsEXT::eValidation )
|
|
|
3063 result += " Validation |";
|
|
|
3064 if ( value & DebugUtilsMessageTypeFlagBitsEXT::ePerformance )
|
|
|
3065 result += " Performance |";
|
|
|
3066 if ( value & DebugUtilsMessageTypeFlagBitsEXT::eDeviceAddressBinding )
|
|
|
3067 result += " DeviceAddressBinding |";
|
|
|
3068
|
|
|
3069 if ( result.size() > 1 )
|
|
|
3070 result.back() = '}';
|
|
|
3071 else
|
|
|
3072 result = "{}";
|
|
|
3073 return result;
|
|
|
3074 }
|
|
|
3075
|
|
|
3076 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DebugUtilsMessengerCallbackDataFlagsEXT )
|
|
|
3077 {
|
|
|
3078 return "{}";
|
|
|
3079 }
|
|
|
3080
|
|
|
3081 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DebugUtilsMessengerCreateFlagsEXT )
|
|
|
3082 {
|
|
|
3083 return "{}";
|
|
|
3084 }
|
|
|
3085
|
|
|
3086 //=== VK_NV_fragment_coverage_to_color ===
|
|
|
3087
|
|
|
3088 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCoverageToColorStateCreateFlagsNV )
|
|
|
3089 {
|
|
|
3090 return "{}";
|
|
|
3091 }
|
|
|
3092
|
|
|
3093 //=== VK_KHR_acceleration_structure ===
|
|
|
3094
|
|
|
3095 VULKAN_HPP_INLINE std::string to_string( GeometryFlagsKHR value )
|
|
|
3096 {
|
|
|
3097 std::string result = "{";
|
|
|
3098 if ( value & GeometryFlagBitsKHR::eOpaque )
|
|
|
3099 result += " Opaque |";
|
|
|
3100 if ( value & GeometryFlagBitsKHR::eNoDuplicateAnyHitInvocation )
|
|
|
3101 result += " NoDuplicateAnyHitInvocation |";
|
|
|
3102
|
|
|
3103 if ( result.size() > 1 )
|
|
|
3104 result.back() = '}';
|
|
|
3105 else
|
|
|
3106 result = "{}";
|
|
|
3107 return result;
|
|
|
3108 }
|
|
|
3109
|
|
|
3110 VULKAN_HPP_INLINE std::string to_string( GeometryInstanceFlagsKHR value )
|
|
|
3111 {
|
|
|
3112 std::string result = "{";
|
|
|
3113 if ( value & GeometryInstanceFlagBitsKHR::eTriangleFacingCullDisable )
|
|
|
3114 result += " TriangleFacingCullDisable |";
|
|
|
3115 if ( value & GeometryInstanceFlagBitsKHR::eTriangleFlipFacing )
|
|
|
3116 result += " TriangleFlipFacing |";
|
|
|
3117 if ( value & GeometryInstanceFlagBitsKHR::eForceOpaque )
|
|
|
3118 result += " ForceOpaque |";
|
|
|
3119 if ( value & GeometryInstanceFlagBitsKHR::eForceNoOpaque )
|
|
|
3120 result += " ForceNoOpaque |";
|
|
|
3121 if ( value & GeometryInstanceFlagBitsKHR::eForceOpacityMicromap2StateEXT )
|
|
|
3122 result += " ForceOpacityMicromap2StateEXT |";
|
|
|
3123 if ( value & GeometryInstanceFlagBitsKHR::eDisableOpacityMicromapsEXT )
|
|
|
3124 result += " DisableOpacityMicromapsEXT |";
|
|
|
3125
|
|
|
3126 if ( result.size() > 1 )
|
|
|
3127 result.back() = '}';
|
|
|
3128 else
|
|
|
3129 result = "{}";
|
|
|
3130 return result;
|
|
|
3131 }
|
|
|
3132
|
|
|
3133 VULKAN_HPP_INLINE std::string to_string( BuildAccelerationStructureFlagsKHR value )
|
|
|
3134 {
|
|
|
3135 std::string result = "{";
|
|
|
3136 if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowUpdate )
|
|
|
3137 result += " AllowUpdate |";
|
|
|
3138 if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowCompaction )
|
|
|
3139 result += " AllowCompaction |";
|
|
|
3140 if ( value & BuildAccelerationStructureFlagBitsKHR::ePreferFastTrace )
|
|
|
3141 result += " PreferFastTrace |";
|
|
|
3142 if ( value & BuildAccelerationStructureFlagBitsKHR::ePreferFastBuild )
|
|
|
3143 result += " PreferFastBuild |";
|
|
|
3144 if ( value & BuildAccelerationStructureFlagBitsKHR::eLowMemory )
|
|
|
3145 result += " LowMemory |";
|
|
|
3146 if ( value & BuildAccelerationStructureFlagBitsKHR::eMotionNV )
|
|
|
3147 result += " MotionNV |";
|
|
|
3148 if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapUpdateEXT )
|
|
|
3149 result += " AllowOpacityMicromapUpdateEXT |";
|
|
|
3150 if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowDisableOpacityMicromapsEXT )
|
|
|
3151 result += " AllowDisableOpacityMicromapsEXT |";
|
|
|
3152 if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapDataUpdateEXT )
|
|
|
3153 result += " AllowOpacityMicromapDataUpdateEXT |";
|
|
|
3154 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
3155 if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowDisplacementMicromapUpdateNV )
|
|
|
3156 result += " AllowDisplacementMicromapUpdateNV |";
|
|
|
3157 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
3158 if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowDataAccess )
|
|
|
3159 result += " AllowDataAccess |";
|
|
|
3160 if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowClusterOpacityMicromapsNV )
|
|
|
3161 result += " AllowClusterOpacityMicromapsNV |";
|
|
|
3162
|
|
|
3163 if ( result.size() > 1 )
|
|
|
3164 result.back() = '}';
|
|
|
3165 else
|
|
|
3166 result = "{}";
|
|
|
3167 return result;
|
|
|
3168 }
|
|
|
3169
|
|
|
3170 VULKAN_HPP_INLINE std::string to_string( AccelerationStructureCreateFlagsKHR value )
|
|
|
3171 {
|
|
|
3172 std::string result = "{";
|
|
|
3173 if ( value & AccelerationStructureCreateFlagBitsKHR::eDeviceAddressCaptureReplay )
|
|
|
3174 result += " DeviceAddressCaptureReplay |";
|
|
|
3175 if ( value & AccelerationStructureCreateFlagBitsKHR::eDescriptorBufferCaptureReplayEXT )
|
|
|
3176 result += " DescriptorBufferCaptureReplayEXT |";
|
|
|
3177 if ( value & AccelerationStructureCreateFlagBitsKHR::eMotionNV )
|
|
|
3178 result += " MotionNV |";
|
|
|
3179
|
|
|
3180 if ( result.size() > 1 )
|
|
|
3181 result.back() = '}';
|
|
|
3182 else
|
|
|
3183 result = "{}";
|
|
|
3184 return result;
|
|
|
3185 }
|
|
|
3186
|
|
|
3187 //=== VK_NV_framebuffer_mixed_samples ===
|
|
|
3188
|
|
|
3189 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCoverageModulationStateCreateFlagsNV )
|
|
|
3190 {
|
|
|
3191 return "{}";
|
|
|
3192 }
|
|
|
3193
|
|
|
3194 //=== VK_EXT_validation_cache ===
|
|
|
3195
|
|
|
3196 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ValidationCacheCreateFlagsEXT )
|
|
|
3197 {
|
|
|
3198 return "{}";
|
|
|
3199 }
|
|
|
3200
|
|
|
3201 //=== VK_AMD_pipeline_compiler_control ===
|
|
|
3202
|
|
|
3203 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCompilerControlFlagsAMD )
|
|
|
3204 {
|
|
|
3205 return "{}";
|
|
|
3206 }
|
|
|
3207
|
|
|
3208 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
3209 //=== VK_FUCHSIA_imagepipe_surface ===
|
|
|
3210
|
|
|
3211 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImagePipeSurfaceCreateFlagsFUCHSIA )
|
|
|
3212 {
|
|
|
3213 return "{}";
|
|
|
3214 }
|
|
|
3215 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
3216
|
|
|
3217 #if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
3218 //=== VK_EXT_metal_surface ===
|
|
|
3219
|
|
|
3220 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MetalSurfaceCreateFlagsEXT )
|
|
|
3221 {
|
|
|
3222 return "{}";
|
|
|
3223 }
|
|
|
3224 #endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
3225
|
|
|
3226 //=== VK_AMD_shader_core_properties2 ===
|
|
|
3227
|
|
|
3228 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderCorePropertiesFlagsAMD )
|
|
|
3229 {
|
|
|
3230 return "{}";
|
|
|
3231 }
|
|
|
3232
|
|
|
3233 //=== VK_NV_coverage_reduction_mode ===
|
|
|
3234
|
|
|
3235 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCoverageReductionStateCreateFlagsNV )
|
|
|
3236 {
|
|
|
3237 return "{}";
|
|
|
3238 }
|
|
|
3239
|
|
|
3240 //=== VK_EXT_headless_surface ===
|
|
|
3241
|
|
|
3242 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( HeadlessSurfaceCreateFlagsEXT )
|
|
|
3243 {
|
|
|
3244 return "{}";
|
|
|
3245 }
|
|
|
3246
|
|
|
3247 //=== VK_NV_device_generated_commands ===
|
|
|
3248
|
|
|
3249 VULKAN_HPP_INLINE std::string to_string( IndirectStateFlagsNV value )
|
|
|
3250 {
|
|
|
3251 std::string result = "{";
|
|
|
3252 if ( value & IndirectStateFlagBitsNV::eFlagFrontface )
|
|
|
3253 result += " FlagFrontface |";
|
|
|
3254
|
|
|
3255 if ( result.size() > 1 )
|
|
|
3256 result.back() = '}';
|
|
|
3257 else
|
|
|
3258 result = "{}";
|
|
|
3259 return result;
|
|
|
3260 }
|
|
|
3261
|
|
|
3262 VULKAN_HPP_INLINE std::string to_string( IndirectCommandsLayoutUsageFlagsNV value )
|
|
|
3263 {
|
|
|
3264 std::string result = "{";
|
|
|
3265 if ( value & IndirectCommandsLayoutUsageFlagBitsNV::eExplicitPreprocess )
|
|
|
3266 result += " ExplicitPreprocess |";
|
|
|
3267 if ( value & IndirectCommandsLayoutUsageFlagBitsNV::eIndexedSequences )
|
|
|
3268 result += " IndexedSequences |";
|
|
|
3269 if ( value & IndirectCommandsLayoutUsageFlagBitsNV::eUnorderedSequences )
|
|
|
3270 result += " UnorderedSequences |";
|
|
|
3271
|
|
|
3272 if ( result.size() > 1 )
|
|
|
3273 result.back() = '}';
|
|
|
3274 else
|
|
|
3275 result = "{}";
|
|
|
3276 return result;
|
|
|
3277 }
|
|
|
3278
|
|
|
3279 //=== VK_EXT_device_memory_report ===
|
|
|
3280
|
|
|
3281 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceMemoryReportFlagsEXT )
|
|
|
3282 {
|
|
|
3283 return "{}";
|
|
|
3284 }
|
|
|
3285
|
|
|
3286 //=== VK_KHR_video_encode_queue ===
|
|
|
3287
|
|
|
3288 VULKAN_HPP_INLINE std::string to_string( VideoEncodeFlagsKHR value )
|
|
|
3289 {
|
|
|
3290 std::string result = "{";
|
|
|
3291 if ( value & VideoEncodeFlagBitsKHR::eIntraRefresh )
|
|
|
3292 result += " IntraRefresh |";
|
|
|
3293 if ( value & VideoEncodeFlagBitsKHR::eWithQuantizationDeltaMap )
|
|
|
3294 result += " WithQuantizationDeltaMap |";
|
|
|
3295 if ( value & VideoEncodeFlagBitsKHR::eWithEmphasisMap )
|
|
|
3296 result += " WithEmphasisMap |";
|
|
|
3297
|
|
|
3298 if ( result.size() > 1 )
|
|
|
3299 result.back() = '}';
|
|
|
3300 else
|
|
|
3301 result = "{}";
|
|
|
3302 return result;
|
|
|
3303 }
|
|
|
3304
|
|
|
3305 VULKAN_HPP_INLINE std::string to_string( VideoEncodeCapabilityFlagsKHR value )
|
|
|
3306 {
|
|
|
3307 std::string result = "{";
|
|
|
3308 if ( value & VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes )
|
|
|
3309 result += " PrecedingExternallyEncodedBytes |";
|
|
|
3310 if ( value & VideoEncodeCapabilityFlagBitsKHR::eInsufficientBitstreamBufferRangeDetection )
|
|
|
3311 result += " InsufficientBitstreamBufferRangeDetection |";
|
|
|
3312 if ( value & VideoEncodeCapabilityFlagBitsKHR::eQuantizationDeltaMap )
|
|
|
3313 result += " QuantizationDeltaMap |";
|
|
|
3314 if ( value & VideoEncodeCapabilityFlagBitsKHR::eEmphasisMap )
|
|
|
3315 result += " EmphasisMap |";
|
|
|
3316
|
|
|
3317 if ( result.size() > 1 )
|
|
|
3318 result.back() = '}';
|
|
|
3319 else
|
|
|
3320 result = "{}";
|
|
|
3321 return result;
|
|
|
3322 }
|
|
|
3323
|
|
|
3324 VULKAN_HPP_INLINE std::string to_string( VideoEncodeFeedbackFlagsKHR value )
|
|
|
3325 {
|
|
|
3326 std::string result = "{";
|
|
|
3327 if ( value & VideoEncodeFeedbackFlagBitsKHR::eBitstreamBufferOffset )
|
|
|
3328 result += " BitstreamBufferOffset |";
|
|
|
3329 if ( value & VideoEncodeFeedbackFlagBitsKHR::eBitstreamBytesWritten )
|
|
|
3330 result += " BitstreamBytesWritten |";
|
|
|
3331 if ( value & VideoEncodeFeedbackFlagBitsKHR::eBitstreamHasOverrides )
|
|
|
3332 result += " BitstreamHasOverrides |";
|
|
|
3333
|
|
|
3334 if ( result.size() > 1 )
|
|
|
3335 result.back() = '}';
|
|
|
3336 else
|
|
|
3337 result = "{}";
|
|
|
3338 return result;
|
|
|
3339 }
|
|
|
3340
|
|
|
3341 VULKAN_HPP_INLINE std::string to_string( VideoEncodeUsageFlagsKHR value )
|
|
|
3342 {
|
|
|
3343 std::string result = "{";
|
|
|
3344 if ( value & VideoEncodeUsageFlagBitsKHR::eTranscoding )
|
|
|
3345 result += " Transcoding |";
|
|
|
3346 if ( value & VideoEncodeUsageFlagBitsKHR::eStreaming )
|
|
|
3347 result += " Streaming |";
|
|
|
3348 if ( value & VideoEncodeUsageFlagBitsKHR::eRecording )
|
|
|
3349 result += " Recording |";
|
|
|
3350 if ( value & VideoEncodeUsageFlagBitsKHR::eConferencing )
|
|
|
3351 result += " Conferencing |";
|
|
|
3352
|
|
|
3353 if ( result.size() > 1 )
|
|
|
3354 result.back() = '}';
|
|
|
3355 else
|
|
|
3356 result = "Default";
|
|
|
3357 return result;
|
|
|
3358 }
|
|
|
3359
|
|
|
3360 VULKAN_HPP_INLINE std::string to_string( VideoEncodeContentFlagsKHR value )
|
|
|
3361 {
|
|
|
3362 std::string result = "{";
|
|
|
3363 if ( value & VideoEncodeContentFlagBitsKHR::eCamera )
|
|
|
3364 result += " Camera |";
|
|
|
3365 if ( value & VideoEncodeContentFlagBitsKHR::eDesktop )
|
|
|
3366 result += " Desktop |";
|
|
|
3367 if ( value & VideoEncodeContentFlagBitsKHR::eRendered )
|
|
|
3368 result += " Rendered |";
|
|
|
3369
|
|
|
3370 if ( result.size() > 1 )
|
|
|
3371 result.back() = '}';
|
|
|
3372 else
|
|
|
3373 result = "Default";
|
|
|
3374 return result;
|
|
|
3375 }
|
|
|
3376
|
|
|
3377 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeRateControlFlagsKHR )
|
|
|
3378 {
|
|
|
3379 return "{}";
|
|
|
3380 }
|
|
|
3381
|
|
|
3382 VULKAN_HPP_INLINE std::string to_string( VideoEncodeRateControlModeFlagsKHR value )
|
|
|
3383 {
|
|
|
3384 std::string result = "{";
|
|
|
3385 if ( value & VideoEncodeRateControlModeFlagBitsKHR::eDisabled )
|
|
|
3386 result += " Disabled |";
|
|
|
3387 if ( value & VideoEncodeRateControlModeFlagBitsKHR::eCbr )
|
|
|
3388 result += " Cbr |";
|
|
|
3389 if ( value & VideoEncodeRateControlModeFlagBitsKHR::eVbr )
|
|
|
3390 result += " Vbr |";
|
|
|
3391
|
|
|
3392 if ( result.size() > 1 )
|
|
|
3393 result.back() = '}';
|
|
|
3394 else
|
|
|
3395 result = "Default";
|
|
|
3396 return result;
|
|
|
3397 }
|
|
|
3398
|
|
|
3399 //=== VK_NV_device_diagnostics_config ===
|
|
|
3400
|
|
|
3401 VULKAN_HPP_INLINE std::string to_string( DeviceDiagnosticsConfigFlagsNV value )
|
|
|
3402 {
|
|
|
3403 std::string result = "{";
|
|
|
3404 if ( value & DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderDebugInfo )
|
|
|
3405 result += " EnableShaderDebugInfo |";
|
|
|
3406 if ( value & DeviceDiagnosticsConfigFlagBitsNV::eEnableResourceTracking )
|
|
|
3407 result += " EnableResourceTracking |";
|
|
|
3408 if ( value & DeviceDiagnosticsConfigFlagBitsNV::eEnableAutomaticCheckpoints )
|
|
|
3409 result += " EnableAutomaticCheckpoints |";
|
|
|
3410 if ( value & DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderErrorReporting )
|
|
|
3411 result += " EnableShaderErrorReporting |";
|
|
|
3412
|
|
|
3413 if ( result.size() > 1 )
|
|
|
3414 result.back() = '}';
|
|
|
3415 else
|
|
|
3416 result = "{}";
|
|
|
3417 return result;
|
|
|
3418 }
|
|
|
3419
|
|
|
3420 //=== VK_QCOM_tile_shading ===
|
|
|
3421
|
|
|
3422 VULKAN_HPP_INLINE std::string to_string( TileShadingRenderPassFlagsQCOM value )
|
|
|
3423 {
|
|
|
3424 std::string result = "{";
|
|
|
3425 if ( value & TileShadingRenderPassFlagBitsQCOM::eEnable )
|
|
|
3426 result += " Enable |";
|
|
|
3427 if ( value & TileShadingRenderPassFlagBitsQCOM::ePerTileExecution )
|
|
|
3428 result += " PerTileExecution |";
|
|
|
3429
|
|
|
3430 if ( result.size() > 1 )
|
|
|
3431 result.back() = '}';
|
|
|
3432 else
|
|
|
3433 result = "{}";
|
|
|
3434 return result;
|
|
|
3435 }
|
|
|
3436
|
|
|
3437 #if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
3438 //=== VK_EXT_metal_objects ===
|
|
|
3439
|
|
|
3440 VULKAN_HPP_INLINE std::string to_string( ExportMetalObjectTypeFlagsEXT value )
|
|
|
3441 {
|
|
|
3442 std::string result = "{";
|
|
|
3443 if ( value & ExportMetalObjectTypeFlagBitsEXT::eMetalDevice )
|
|
|
3444 result += " MetalDevice |";
|
|
|
3445 if ( value & ExportMetalObjectTypeFlagBitsEXT::eMetalCommandQueue )
|
|
|
3446 result += " MetalCommandQueue |";
|
|
|
3447 if ( value & ExportMetalObjectTypeFlagBitsEXT::eMetalBuffer )
|
|
|
3448 result += " MetalBuffer |";
|
|
|
3449 if ( value & ExportMetalObjectTypeFlagBitsEXT::eMetalTexture )
|
|
|
3450 result += " MetalTexture |";
|
|
|
3451 if ( value & ExportMetalObjectTypeFlagBitsEXT::eMetalIosurface )
|
|
|
3452 result += " MetalIosurface |";
|
|
|
3453 if ( value & ExportMetalObjectTypeFlagBitsEXT::eMetalSharedEvent )
|
|
|
3454 result += " MetalSharedEvent |";
|
|
|
3455
|
|
|
3456 if ( result.size() > 1 )
|
|
|
3457 result.back() = '}';
|
|
|
3458 else
|
|
|
3459 result = "{}";
|
|
|
3460 return result;
|
|
|
3461 }
|
|
|
3462 #endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
3463
|
|
|
3464 //=== VK_EXT_graphics_pipeline_library ===
|
|
|
3465
|
|
|
3466 VULKAN_HPP_INLINE std::string to_string( GraphicsPipelineLibraryFlagsEXT value )
|
|
|
3467 {
|
|
|
3468 std::string result = "{";
|
|
|
3469 if ( value & GraphicsPipelineLibraryFlagBitsEXT::eVertexInputInterface )
|
|
|
3470 result += " VertexInputInterface |";
|
|
|
3471 if ( value & GraphicsPipelineLibraryFlagBitsEXT::ePreRasterizationShaders )
|
|
|
3472 result += " PreRasterizationShaders |";
|
|
|
3473 if ( value & GraphicsPipelineLibraryFlagBitsEXT::eFragmentShader )
|
|
|
3474 result += " FragmentShader |";
|
|
|
3475 if ( value & GraphicsPipelineLibraryFlagBitsEXT::eFragmentOutputInterface )
|
|
|
3476 result += " FragmentOutputInterface |";
|
|
|
3477
|
|
|
3478 if ( result.size() > 1 )
|
|
|
3479 result.back() = '}';
|
|
|
3480 else
|
|
|
3481 result = "{}";
|
|
|
3482 return result;
|
|
|
3483 }
|
|
|
3484
|
|
|
3485 //=== VK_NV_ray_tracing_motion_blur ===
|
|
|
3486
|
|
|
3487 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureMotionInfoFlagsNV )
|
|
|
3488 {
|
|
|
3489 return "{}";
|
|
|
3490 }
|
|
|
3491
|
|
|
3492 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureMotionInstanceFlagsNV )
|
|
|
3493 {
|
|
|
3494 return "{}";
|
|
|
3495 }
|
|
|
3496
|
|
|
3497 //=== VK_EXT_image_compression_control ===
|
|
|
3498
|
|
|
3499 VULKAN_HPP_INLINE std::string to_string( ImageCompressionFlagsEXT value )
|
|
|
3500 {
|
|
|
3501 std::string result = "{";
|
|
|
3502 if ( value & ImageCompressionFlagBitsEXT::eFixedRateDefault )
|
|
|
3503 result += " FixedRateDefault |";
|
|
|
3504 if ( value & ImageCompressionFlagBitsEXT::eFixedRateExplicit )
|
|
|
3505 result += " FixedRateExplicit |";
|
|
|
3506 if ( value & ImageCompressionFlagBitsEXT::eDisabled )
|
|
|
3507 result += " Disabled |";
|
|
|
3508
|
|
|
3509 if ( result.size() > 1 )
|
|
|
3510 result.back() = '}';
|
|
|
3511 else
|
|
|
3512 result = "Default";
|
|
|
3513 return result;
|
|
|
3514 }
|
|
|
3515
|
|
|
3516 VULKAN_HPP_INLINE std::string to_string( ImageCompressionFixedRateFlagsEXT value )
|
|
|
3517 {
|
|
|
3518 std::string result = "{";
|
|
|
3519 if ( value & ImageCompressionFixedRateFlagBitsEXT::e1Bpc )
|
|
|
3520 result += " 1Bpc |";
|
|
|
3521 if ( value & ImageCompressionFixedRateFlagBitsEXT::e2Bpc )
|
|
|
3522 result += " 2Bpc |";
|
|
|
3523 if ( value & ImageCompressionFixedRateFlagBitsEXT::e3Bpc )
|
|
|
3524 result += " 3Bpc |";
|
|
|
3525 if ( value & ImageCompressionFixedRateFlagBitsEXT::e4Bpc )
|
|
|
3526 result += " 4Bpc |";
|
|
|
3527 if ( value & ImageCompressionFixedRateFlagBitsEXT::e5Bpc )
|
|
|
3528 result += " 5Bpc |";
|
|
|
3529 if ( value & ImageCompressionFixedRateFlagBitsEXT::e6Bpc )
|
|
|
3530 result += " 6Bpc |";
|
|
|
3531 if ( value & ImageCompressionFixedRateFlagBitsEXT::e7Bpc )
|
|
|
3532 result += " 7Bpc |";
|
|
|
3533 if ( value & ImageCompressionFixedRateFlagBitsEXT::e8Bpc )
|
|
|
3534 result += " 8Bpc |";
|
|
|
3535 if ( value & ImageCompressionFixedRateFlagBitsEXT::e9Bpc )
|
|
|
3536 result += " 9Bpc |";
|
|
|
3537 if ( value & ImageCompressionFixedRateFlagBitsEXT::e10Bpc )
|
|
|
3538 result += " 10Bpc |";
|
|
|
3539 if ( value & ImageCompressionFixedRateFlagBitsEXT::e11Bpc )
|
|
|
3540 result += " 11Bpc |";
|
|
|
3541 if ( value & ImageCompressionFixedRateFlagBitsEXT::e12Bpc )
|
|
|
3542 result += " 12Bpc |";
|
|
|
3543 if ( value & ImageCompressionFixedRateFlagBitsEXT::e13Bpc )
|
|
|
3544 result += " 13Bpc |";
|
|
|
3545 if ( value & ImageCompressionFixedRateFlagBitsEXT::e14Bpc )
|
|
|
3546 result += " 14Bpc |";
|
|
|
3547 if ( value & ImageCompressionFixedRateFlagBitsEXT::e15Bpc )
|
|
|
3548 result += " 15Bpc |";
|
|
|
3549 if ( value & ImageCompressionFixedRateFlagBitsEXT::e16Bpc )
|
|
|
3550 result += " 16Bpc |";
|
|
|
3551 if ( value & ImageCompressionFixedRateFlagBitsEXT::e17Bpc )
|
|
|
3552 result += " 17Bpc |";
|
|
|
3553 if ( value & ImageCompressionFixedRateFlagBitsEXT::e18Bpc )
|
|
|
3554 result += " 18Bpc |";
|
|
|
3555 if ( value & ImageCompressionFixedRateFlagBitsEXT::e19Bpc )
|
|
|
3556 result += " 19Bpc |";
|
|
|
3557 if ( value & ImageCompressionFixedRateFlagBitsEXT::e20Bpc )
|
|
|
3558 result += " 20Bpc |";
|
|
|
3559 if ( value & ImageCompressionFixedRateFlagBitsEXT::e21Bpc )
|
|
|
3560 result += " 21Bpc |";
|
|
|
3561 if ( value & ImageCompressionFixedRateFlagBitsEXT::e22Bpc )
|
|
|
3562 result += " 22Bpc |";
|
|
|
3563 if ( value & ImageCompressionFixedRateFlagBitsEXT::e23Bpc )
|
|
|
3564 result += " 23Bpc |";
|
|
|
3565 if ( value & ImageCompressionFixedRateFlagBitsEXT::e24Bpc )
|
|
|
3566 result += " 24Bpc |";
|
|
|
3567
|
|
|
3568 if ( result.size() > 1 )
|
|
|
3569 result.back() = '}';
|
|
|
3570 else
|
|
|
3571 result = "None";
|
|
|
3572 return result;
|
|
|
3573 }
|
|
|
3574
|
|
|
3575 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
|
|
|
3576 //=== VK_EXT_directfb_surface ===
|
|
|
3577
|
|
|
3578 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DirectFBSurfaceCreateFlagsEXT )
|
|
|
3579 {
|
|
|
3580 return "{}";
|
|
|
3581 }
|
|
|
3582 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
|
|
|
3583
|
|
|
3584 //=== VK_EXT_device_address_binding_report ===
|
|
|
3585
|
|
|
3586 VULKAN_HPP_INLINE std::string to_string( DeviceAddressBindingFlagsEXT value )
|
|
|
3587 {
|
|
|
3588 std::string result = "{";
|
|
|
3589 if ( value & DeviceAddressBindingFlagBitsEXT::eInternalObject )
|
|
|
3590 result += " InternalObject |";
|
|
|
3591
|
|
|
3592 if ( result.size() > 1 )
|
|
|
3593 result.back() = '}';
|
|
|
3594 else
|
|
|
3595 result = "{}";
|
|
|
3596 return result;
|
|
|
3597 }
|
|
|
3598
|
|
|
3599 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
3600 //=== VK_FUCHSIA_buffer_collection ===
|
|
|
3601
|
|
|
3602 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageFormatConstraintsFlagsFUCHSIA )
|
|
|
3603 {
|
|
|
3604 return "{}";
|
|
|
3605 }
|
|
|
3606
|
|
|
3607 VULKAN_HPP_INLINE std::string to_string( ImageConstraintsInfoFlagsFUCHSIA value )
|
|
|
3608 {
|
|
|
3609 std::string result = "{";
|
|
|
3610 if ( value & ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadRarely )
|
|
|
3611 result += " CpuReadRarely |";
|
|
|
3612 if ( value & ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadOften )
|
|
|
3613 result += " CpuReadOften |";
|
|
|
3614 if ( value & ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteRarely )
|
|
|
3615 result += " CpuWriteRarely |";
|
|
|
3616 if ( value & ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteOften )
|
|
|
3617 result += " CpuWriteOften |";
|
|
|
3618 if ( value & ImageConstraintsInfoFlagBitsFUCHSIA::eProtectedOptional )
|
|
|
3619 result += " ProtectedOptional |";
|
|
|
3620
|
|
|
3621 if ( result.size() > 1 )
|
|
|
3622 result.back() = '}';
|
|
|
3623 else
|
|
|
3624 result = "{}";
|
|
|
3625 return result;
|
|
|
3626 }
|
|
|
3627 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
3628
|
|
|
3629 //=== VK_EXT_frame_boundary ===
|
|
|
3630
|
|
|
3631 VULKAN_HPP_INLINE std::string to_string( FrameBoundaryFlagsEXT value )
|
|
|
3632 {
|
|
|
3633 std::string result = "{";
|
|
|
3634 if ( value & FrameBoundaryFlagBitsEXT::eFrameEnd )
|
|
|
3635 result += " FrameEnd |";
|
|
|
3636
|
|
|
3637 if ( result.size() > 1 )
|
|
|
3638 result.back() = '}';
|
|
|
3639 else
|
|
|
3640 result = "{}";
|
|
|
3641 return result;
|
|
|
3642 }
|
|
|
3643
|
|
|
3644 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
|
3645 //=== VK_QNX_screen_surface ===
|
|
|
3646
|
|
|
3647 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ScreenSurfaceCreateFlagsQNX )
|
|
|
3648 {
|
|
|
3649 return "{}";
|
|
|
3650 }
|
|
|
3651 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
|
3652
|
|
|
3653 //=== VK_VALVE_video_encode_rgb_conversion ===
|
|
|
3654
|
|
|
3655 VULKAN_HPP_INLINE std::string to_string( VideoEncodeRgbModelConversionFlagsVALVE value )
|
|
|
3656 {
|
|
|
3657 std::string result = "{";
|
|
|
3658 if ( value & VideoEncodeRgbModelConversionFlagBitsVALVE::eRgbIdentity )
|
|
|
3659 result += " RgbIdentity |";
|
|
|
3660 if ( value & VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcrIdentity )
|
|
|
3661 result += " YcbcrIdentity |";
|
|
|
3662 if ( value & VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr709 )
|
|
|
3663 result += " Ycbcr709 |";
|
|
|
3664 if ( value & VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr601 )
|
|
|
3665 result += " Ycbcr601 |";
|
|
|
3666 if ( value & VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr2020 )
|
|
|
3667 result += " Ycbcr2020 |";
|
|
|
3668
|
|
|
3669 if ( result.size() > 1 )
|
|
|
3670 result.back() = '}';
|
|
|
3671 else
|
|
|
3672 result = "{}";
|
|
|
3673 return result;
|
|
|
3674 }
|
|
|
3675
|
|
|
3676 VULKAN_HPP_INLINE std::string to_string( VideoEncodeRgbRangeCompressionFlagsVALVE value )
|
|
|
3677 {
|
|
|
3678 std::string result = "{";
|
|
|
3679 if ( value & VideoEncodeRgbRangeCompressionFlagBitsVALVE::eFullRange )
|
|
|
3680 result += " FullRange |";
|
|
|
3681 if ( value & VideoEncodeRgbRangeCompressionFlagBitsVALVE::eNarrowRange )
|
|
|
3682 result += " NarrowRange |";
|
|
|
3683
|
|
|
3684 if ( result.size() > 1 )
|
|
|
3685 result.back() = '}';
|
|
|
3686 else
|
|
|
3687 result = "{}";
|
|
|
3688 return result;
|
|
|
3689 }
|
|
|
3690
|
|
|
3691 VULKAN_HPP_INLINE std::string to_string( VideoEncodeRgbChromaOffsetFlagsVALVE value )
|
|
|
3692 {
|
|
|
3693 std::string result = "{";
|
|
|
3694 if ( value & VideoEncodeRgbChromaOffsetFlagBitsVALVE::eCositedEven )
|
|
|
3695 result += " CositedEven |";
|
|
|
3696 if ( value & VideoEncodeRgbChromaOffsetFlagBitsVALVE::eMidpoint )
|
|
|
3697 result += " Midpoint |";
|
|
|
3698
|
|
|
3699 if ( result.size() > 1 )
|
|
|
3700 result.back() = '}';
|
|
|
3701 else
|
|
|
3702 result = "{}";
|
|
|
3703 return result;
|
|
|
3704 }
|
|
|
3705
|
|
|
3706 //=== VK_EXT_opacity_micromap ===
|
|
|
3707
|
|
|
3708 VULKAN_HPP_INLINE std::string to_string( BuildMicromapFlagsEXT value )
|
|
|
3709 {
|
|
|
3710 std::string result = "{";
|
|
|
3711 if ( value & BuildMicromapFlagBitsEXT::ePreferFastTrace )
|
|
|
3712 result += " PreferFastTrace |";
|
|
|
3713 if ( value & BuildMicromapFlagBitsEXT::ePreferFastBuild )
|
|
|
3714 result += " PreferFastBuild |";
|
|
|
3715 if ( value & BuildMicromapFlagBitsEXT::eAllowCompaction )
|
|
|
3716 result += " AllowCompaction |";
|
|
|
3717
|
|
|
3718 if ( result.size() > 1 )
|
|
|
3719 result.back() = '}';
|
|
|
3720 else
|
|
|
3721 result = "{}";
|
|
|
3722 return result;
|
|
|
3723 }
|
|
|
3724
|
|
|
3725 VULKAN_HPP_INLINE std::string to_string( MicromapCreateFlagsEXT value )
|
|
|
3726 {
|
|
|
3727 std::string result = "{";
|
|
|
3728 if ( value & MicromapCreateFlagBitsEXT::eDeviceAddressCaptureReplay )
|
|
|
3729 result += " DeviceAddressCaptureReplay |";
|
|
|
3730
|
|
|
3731 if ( result.size() > 1 )
|
|
|
3732 result.back() = '}';
|
|
|
3733 else
|
|
|
3734 result = "{}";
|
|
|
3735 return result;
|
|
|
3736 }
|
|
|
3737
|
|
|
3738 //=== VK_ARM_scheduling_controls ===
|
|
|
3739
|
|
|
3740 VULKAN_HPP_INLINE std::string to_string( PhysicalDeviceSchedulingControlsFlagsARM value )
|
|
|
3741 {
|
|
|
3742 std::string result = "{";
|
|
|
3743 if ( value & PhysicalDeviceSchedulingControlsFlagBitsARM::eShaderCoreCount )
|
|
|
3744 result += " ShaderCoreCount |";
|
|
|
3745
|
|
|
3746 if ( result.size() > 1 )
|
|
|
3747 result.back() = '}';
|
|
|
3748 else
|
|
|
3749 result = "{}";
|
|
|
3750 return result;
|
|
|
3751 }
|
|
|
3752
|
|
|
3753 //=== VK_LUNARG_direct_driver_loading ===
|
|
|
3754
|
|
|
3755 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DirectDriverLoadingFlagsLUNARG )
|
|
|
3756 {
|
|
|
3757 return "{}";
|
|
|
3758 }
|
|
|
3759
|
|
|
3760 //=== VK_ARM_tensors ===
|
|
|
3761
|
|
|
3762 VULKAN_HPP_INLINE std::string to_string( TensorCreateFlagsARM value )
|
|
|
3763 {
|
|
|
3764 std::string result = "{";
|
|
|
3765 if ( value & TensorCreateFlagBitsARM::eMutableFormat )
|
|
|
3766 result += " MutableFormat |";
|
|
|
3767 if ( value & TensorCreateFlagBitsARM::eProtected )
|
|
|
3768 result += " Protected |";
|
|
|
3769 if ( value & TensorCreateFlagBitsARM::eDescriptorBufferCaptureReplay )
|
|
|
3770 result += " DescriptorBufferCaptureReplay |";
|
|
|
3771
|
|
|
3772 if ( result.size() > 1 )
|
|
|
3773 result.back() = '}';
|
|
|
3774 else
|
|
|
3775 result = "{}";
|
|
|
3776 return result;
|
|
|
3777 }
|
|
|
3778
|
|
|
3779 VULKAN_HPP_INLINE std::string to_string( TensorViewCreateFlagsARM value )
|
|
|
3780 {
|
|
|
3781 std::string result = "{";
|
|
|
3782 if ( value & TensorViewCreateFlagBitsARM::eDescriptorBufferCaptureReplay )
|
|
|
3783 result += " DescriptorBufferCaptureReplay |";
|
|
|
3784
|
|
|
3785 if ( result.size() > 1 )
|
|
|
3786 result.back() = '}';
|
|
|
3787 else
|
|
|
3788 result = "{}";
|
|
|
3789 return result;
|
|
|
3790 }
|
|
|
3791
|
|
|
3792 VULKAN_HPP_INLINE std::string to_string( TensorUsageFlagsARM value )
|
|
|
3793 {
|
|
|
3794 std::string result = "{";
|
|
|
3795 if ( value & TensorUsageFlagBitsARM::eShader )
|
|
|
3796 result += " Shader |";
|
|
|
3797 if ( value & TensorUsageFlagBitsARM::eTransferSrc )
|
|
|
3798 result += " TransferSrc |";
|
|
|
3799 if ( value & TensorUsageFlagBitsARM::eTransferDst )
|
|
|
3800 result += " TransferDst |";
|
|
|
3801 if ( value & TensorUsageFlagBitsARM::eImageAliasing )
|
|
|
3802 result += " ImageAliasing |";
|
|
|
3803 if ( value & TensorUsageFlagBitsARM::eDataGraph )
|
|
|
3804 result += " DataGraph |";
|
|
|
3805
|
|
|
3806 if ( result.size() > 1 )
|
|
|
3807 result.back() = '}';
|
|
|
3808 else
|
|
|
3809 result = "{}";
|
|
|
3810 return result;
|
|
|
3811 }
|
|
|
3812
|
|
|
3813 //=== VK_NV_optical_flow ===
|
|
|
3814
|
|
|
3815 VULKAN_HPP_INLINE std::string to_string( OpticalFlowUsageFlagsNV value )
|
|
|
3816 {
|
|
|
3817 std::string result = "{";
|
|
|
3818 if ( value & OpticalFlowUsageFlagBitsNV::eInput )
|
|
|
3819 result += " Input |";
|
|
|
3820 if ( value & OpticalFlowUsageFlagBitsNV::eOutput )
|
|
|
3821 result += " Output |";
|
|
|
3822 if ( value & OpticalFlowUsageFlagBitsNV::eHint )
|
|
|
3823 result += " Hint |";
|
|
|
3824 if ( value & OpticalFlowUsageFlagBitsNV::eCost )
|
|
|
3825 result += " Cost |";
|
|
|
3826 if ( value & OpticalFlowUsageFlagBitsNV::eGlobalFlow )
|
|
|
3827 result += " GlobalFlow |";
|
|
|
3828
|
|
|
3829 if ( result.size() > 1 )
|
|
|
3830 result.back() = '}';
|
|
|
3831 else
|
|
|
3832 result = "Unknown";
|
|
|
3833 return result;
|
|
|
3834 }
|
|
|
3835
|
|
|
3836 VULKAN_HPP_INLINE std::string to_string( OpticalFlowGridSizeFlagsNV value )
|
|
|
3837 {
|
|
|
3838 std::string result = "{";
|
|
|
3839 if ( value & OpticalFlowGridSizeFlagBitsNV::e1X1 )
|
|
|
3840 result += " 1X1 |";
|
|
|
3841 if ( value & OpticalFlowGridSizeFlagBitsNV::e2X2 )
|
|
|
3842 result += " 2X2 |";
|
|
|
3843 if ( value & OpticalFlowGridSizeFlagBitsNV::e4X4 )
|
|
|
3844 result += " 4X4 |";
|
|
|
3845 if ( value & OpticalFlowGridSizeFlagBitsNV::e8X8 )
|
|
|
3846 result += " 8X8 |";
|
|
|
3847
|
|
|
3848 if ( result.size() > 1 )
|
|
|
3849 result.back() = '}';
|
|
|
3850 else
|
|
|
3851 result = "Unknown";
|
|
|
3852 return result;
|
|
|
3853 }
|
|
|
3854
|
|
|
3855 VULKAN_HPP_INLINE std::string to_string( OpticalFlowSessionCreateFlagsNV value )
|
|
|
3856 {
|
|
|
3857 std::string result = "{";
|
|
|
3858 if ( value & OpticalFlowSessionCreateFlagBitsNV::eEnableHint )
|
|
|
3859 result += " EnableHint |";
|
|
|
3860 if ( value & OpticalFlowSessionCreateFlagBitsNV::eEnableCost )
|
|
|
3861 result += " EnableCost |";
|
|
|
3862 if ( value & OpticalFlowSessionCreateFlagBitsNV::eEnableGlobalFlow )
|
|
|
3863 result += " EnableGlobalFlow |";
|
|
|
3864 if ( value & OpticalFlowSessionCreateFlagBitsNV::eAllowRegions )
|
|
|
3865 result += " AllowRegions |";
|
|
|
3866 if ( value & OpticalFlowSessionCreateFlagBitsNV::eBothDirections )
|
|
|
3867 result += " BothDirections |";
|
|
|
3868
|
|
|
3869 if ( result.size() > 1 )
|
|
|
3870 result.back() = '}';
|
|
|
3871 else
|
|
|
3872 result = "{}";
|
|
|
3873 return result;
|
|
|
3874 }
|
|
|
3875
|
|
|
3876 VULKAN_HPP_INLINE std::string to_string( OpticalFlowExecuteFlagsNV value )
|
|
|
3877 {
|
|
|
3878 std::string result = "{";
|
|
|
3879 if ( value & OpticalFlowExecuteFlagBitsNV::eDisableTemporalHints )
|
|
|
3880 result += " DisableTemporalHints |";
|
|
|
3881
|
|
|
3882 if ( result.size() > 1 )
|
|
|
3883 result.back() = '}';
|
|
|
3884 else
|
|
|
3885 result = "{}";
|
|
|
3886 return result;
|
|
|
3887 }
|
|
|
3888
|
|
|
3889 //=== VK_EXT_shader_object ===
|
|
|
3890
|
|
|
3891 VULKAN_HPP_INLINE std::string to_string( ShaderCreateFlagsEXT value )
|
|
|
3892 {
|
|
|
3893 std::string result = "{";
|
|
|
3894 if ( value & ShaderCreateFlagBitsEXT::eLinkStage )
|
|
|
3895 result += " LinkStage |";
|
|
|
3896 if ( value & ShaderCreateFlagBitsEXT::eAllowVaryingSubgroupSize )
|
|
|
3897 result += " AllowVaryingSubgroupSize |";
|
|
|
3898 if ( value & ShaderCreateFlagBitsEXT::eRequireFullSubgroups )
|
|
|
3899 result += " RequireFullSubgroups |";
|
|
|
3900 if ( value & ShaderCreateFlagBitsEXT::eNoTaskShader )
|
|
|
3901 result += " NoTaskShader |";
|
|
|
3902 if ( value & ShaderCreateFlagBitsEXT::eDispatchBase )
|
|
|
3903 result += " DispatchBase |";
|
|
|
3904 if ( value & ShaderCreateFlagBitsEXT::eFragmentShadingRateAttachment )
|
|
|
3905 result += " FragmentShadingRateAttachment |";
|
|
|
3906 if ( value & ShaderCreateFlagBitsEXT::eFragmentDensityMapAttachment )
|
|
|
3907 result += " FragmentDensityMapAttachment |";
|
|
|
3908 if ( value & ShaderCreateFlagBitsEXT::eIndirectBindable )
|
|
|
3909 result += " IndirectBindable |";
|
|
|
3910 if ( value & ShaderCreateFlagBitsEXT::e64BitIndexing )
|
|
|
3911 result += " 64BitIndexing |";
|
|
|
3912
|
|
|
3913 if ( result.size() > 1 )
|
|
|
3914 result.back() = '}';
|
|
|
3915 else
|
|
|
3916 result = "{}";
|
|
|
3917 return result;
|
|
|
3918 }
|
|
|
3919
|
|
|
3920 //=== VK_KHR_surface_maintenance1 ===
|
|
|
3921
|
|
|
3922 VULKAN_HPP_INLINE std::string to_string( PresentScalingFlagsKHR value )
|
|
|
3923 {
|
|
|
3924 std::string result = "{";
|
|
|
3925 if ( value & PresentScalingFlagBitsKHR::eOneToOne )
|
|
|
3926 result += " OneToOne |";
|
|
|
3927 if ( value & PresentScalingFlagBitsKHR::eAspectRatioStretch )
|
|
|
3928 result += " AspectRatioStretch |";
|
|
|
3929 if ( value & PresentScalingFlagBitsKHR::eStretch )
|
|
|
3930 result += " Stretch |";
|
|
|
3931
|
|
|
3932 if ( result.size() > 1 )
|
|
|
3933 result.back() = '}';
|
|
|
3934 else
|
|
|
3935 result = "{}";
|
|
|
3936 return result;
|
|
|
3937 }
|
|
|
3938
|
|
|
3939 VULKAN_HPP_INLINE std::string to_string( PresentGravityFlagsKHR value )
|
|
|
3940 {
|
|
|
3941 std::string result = "{";
|
|
|
3942 if ( value & PresentGravityFlagBitsKHR::eMin )
|
|
|
3943 result += " Min |";
|
|
|
3944 if ( value & PresentGravityFlagBitsKHR::eMax )
|
|
|
3945 result += " Max |";
|
|
|
3946 if ( value & PresentGravityFlagBitsKHR::eCentered )
|
|
|
3947 result += " Centered |";
|
|
|
3948
|
|
|
3949 if ( result.size() > 1 )
|
|
|
3950 result.back() = '}';
|
|
|
3951 else
|
|
|
3952 result = "{}";
|
|
|
3953 return result;
|
|
|
3954 }
|
|
|
3955
|
|
|
3956 //=== VK_ARM_data_graph ===
|
|
|
3957
|
|
|
3958 VULKAN_HPP_INLINE std::string to_string( DataGraphPipelineSessionCreateFlagsARM value )
|
|
|
3959 {
|
|
|
3960 std::string result = "{";
|
|
|
3961 if ( value & DataGraphPipelineSessionCreateFlagBitsARM::eProtected )
|
|
|
3962 result += " Protected |";
|
|
|
3963
|
|
|
3964 if ( result.size() > 1 )
|
|
|
3965 result.back() = '}';
|
|
|
3966 else
|
|
|
3967 result = "{}";
|
|
|
3968 return result;
|
|
|
3969 }
|
|
|
3970
|
|
|
3971 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphPipelineDispatchFlagsARM )
|
|
|
3972 {
|
|
|
3973 return "{}";
|
|
|
3974 }
|
|
|
3975
|
|
|
3976 //=== VK_KHR_video_encode_av1 ===
|
|
|
3977
|
|
|
3978 VULKAN_HPP_INLINE std::string to_string( VideoEncodeAV1CapabilityFlagsKHR value )
|
|
|
3979 {
|
|
|
3980 std::string result = "{";
|
|
|
3981 if ( value & VideoEncodeAV1CapabilityFlagBitsKHR::ePerRateControlGroupMinMaxQIndex )
|
|
|
3982 result += " PerRateControlGroupMinMaxQIndex |";
|
|
|
3983 if ( value & VideoEncodeAV1CapabilityFlagBitsKHR::eGenerateObuExtensionHeader )
|
|
|
3984 result += " GenerateObuExtensionHeader |";
|
|
|
3985 if ( value & VideoEncodeAV1CapabilityFlagBitsKHR::ePrimaryReferenceCdfOnly )
|
|
|
3986 result += " PrimaryReferenceCdfOnly |";
|
|
|
3987 if ( value & VideoEncodeAV1CapabilityFlagBitsKHR::eFrameSizeOverride )
|
|
|
3988 result += " FrameSizeOverride |";
|
|
|
3989 if ( value & VideoEncodeAV1CapabilityFlagBitsKHR::eMotionVectorScaling )
|
|
|
3990 result += " MotionVectorScaling |";
|
|
|
3991 if ( value & VideoEncodeAV1CapabilityFlagBitsKHR::eCompoundPredictionIntraRefresh )
|
|
|
3992 result += " CompoundPredictionIntraRefresh |";
|
|
|
3993
|
|
|
3994 if ( result.size() > 1 )
|
|
|
3995 result.back() = '}';
|
|
|
3996 else
|
|
|
3997 result = "{}";
|
|
|
3998 return result;
|
|
|
3999 }
|
|
|
4000
|
|
|
4001 VULKAN_HPP_INLINE std::string to_string( VideoEncodeAV1StdFlagsKHR value )
|
|
|
4002 {
|
|
|
4003 std::string result = "{";
|
|
|
4004 if ( value & VideoEncodeAV1StdFlagBitsKHR::eUniformTileSpacingFlagSet )
|
|
|
4005 result += " UniformTileSpacingFlagSet |";
|
|
|
4006 if ( value & VideoEncodeAV1StdFlagBitsKHR::eSkipModePresentUnset )
|
|
|
4007 result += " SkipModePresentUnset |";
|
|
|
4008 if ( value & VideoEncodeAV1StdFlagBitsKHR::ePrimaryRefFrame )
|
|
|
4009 result += " PrimaryRefFrame |";
|
|
|
4010 if ( value & VideoEncodeAV1StdFlagBitsKHR::eDeltaQ )
|
|
|
4011 result += " DeltaQ |";
|
|
|
4012
|
|
|
4013 if ( result.size() > 1 )
|
|
|
4014 result.back() = '}';
|
|
|
4015 else
|
|
|
4016 result = "{}";
|
|
|
4017 return result;
|
|
|
4018 }
|
|
|
4019
|
|
|
4020 VULKAN_HPP_INLINE std::string to_string( VideoEncodeAV1SuperblockSizeFlagsKHR value )
|
|
|
4021 {
|
|
|
4022 std::string result = "{";
|
|
|
4023 if ( value & VideoEncodeAV1SuperblockSizeFlagBitsKHR::e64 )
|
|
|
4024 result += " 64 |";
|
|
|
4025 if ( value & VideoEncodeAV1SuperblockSizeFlagBitsKHR::e128 )
|
|
|
4026 result += " 128 |";
|
|
|
4027
|
|
|
4028 if ( result.size() > 1 )
|
|
|
4029 result.back() = '}';
|
|
|
4030 else
|
|
|
4031 result = "{}";
|
|
|
4032 return result;
|
|
|
4033 }
|
|
|
4034
|
|
|
4035 VULKAN_HPP_INLINE std::string to_string( VideoEncodeAV1RateControlFlagsKHR value )
|
|
|
4036 {
|
|
|
4037 std::string result = "{";
|
|
|
4038 if ( value & VideoEncodeAV1RateControlFlagBitsKHR::eRegularGop )
|
|
|
4039 result += " RegularGop |";
|
|
|
4040 if ( value & VideoEncodeAV1RateControlFlagBitsKHR::eTemporalLayerPatternDyadic )
|
|
|
4041 result += " TemporalLayerPatternDyadic |";
|
|
|
4042 if ( value & VideoEncodeAV1RateControlFlagBitsKHR::eReferencePatternFlat )
|
|
|
4043 result += " ReferencePatternFlat |";
|
|
|
4044 if ( value & VideoEncodeAV1RateControlFlagBitsKHR::eReferencePatternDyadic )
|
|
|
4045 result += " ReferencePatternDyadic |";
|
|
|
4046
|
|
|
4047 if ( result.size() > 1 )
|
|
|
4048 result.back() = '}';
|
|
|
4049 else
|
|
|
4050 result = "{}";
|
|
|
4051 return result;
|
|
|
4052 }
|
|
|
4053
|
|
|
4054 //=== VK_KHR_copy_memory_indirect ===
|
|
|
4055
|
|
|
4056 VULKAN_HPP_INLINE std::string to_string( AddressCopyFlagsKHR value )
|
|
|
4057 {
|
|
|
4058 std::string result = "{";
|
|
|
4059 if ( value & AddressCopyFlagBitsKHR::eDeviceLocal )
|
|
|
4060 result += " DeviceLocal |";
|
|
|
4061 if ( value & AddressCopyFlagBitsKHR::eSparse )
|
|
|
4062 result += " Sparse |";
|
|
|
4063 if ( value & AddressCopyFlagBitsKHR::eProtected )
|
|
|
4064 result += " Protected |";
|
|
|
4065
|
|
|
4066 if ( result.size() > 1 )
|
|
|
4067 result.back() = '}';
|
|
|
4068 else
|
|
|
4069 result = "{}";
|
|
|
4070 return result;
|
|
|
4071 }
|
|
|
4072
|
|
|
4073 //=== VK_EXT_memory_decompression ===
|
|
|
4074
|
|
|
4075 VULKAN_HPP_INLINE std::string to_string( MemoryDecompressionMethodFlagsEXT value )
|
|
|
4076 {
|
|
|
4077 std::string result = "{";
|
|
|
4078 if ( value & MemoryDecompressionMethodFlagBitsEXT::eGdeflate10 )
|
|
|
4079 result += " Gdeflate10 |";
|
|
|
4080
|
|
|
4081 if ( result.size() > 1 )
|
|
|
4082 result.back() = '}';
|
|
|
4083 else
|
|
|
4084 result = "{}";
|
|
|
4085 return result;
|
|
|
4086 }
|
|
|
4087
|
|
|
4088 //=== VK_KHR_video_encode_intra_refresh ===
|
|
|
4089
|
|
|
4090 VULKAN_HPP_INLINE std::string to_string( VideoEncodeIntraRefreshModeFlagsKHR value )
|
|
|
4091 {
|
|
|
4092 std::string result = "{";
|
|
|
4093 if ( value & VideoEncodeIntraRefreshModeFlagBitsKHR::ePerPicturePartition )
|
|
|
4094 result += " PerPicturePartition |";
|
|
|
4095 if ( value & VideoEncodeIntraRefreshModeFlagBitsKHR::eBlockBased )
|
|
|
4096 result += " BlockBased |";
|
|
|
4097 if ( value & VideoEncodeIntraRefreshModeFlagBitsKHR::eBlockRowBased )
|
|
|
4098 result += " BlockRowBased |";
|
|
|
4099 if ( value & VideoEncodeIntraRefreshModeFlagBitsKHR::eBlockColumnBased )
|
|
|
4100 result += " BlockColumnBased |";
|
|
|
4101
|
|
|
4102 if ( result.size() > 1 )
|
|
|
4103 result.back() = '}';
|
|
|
4104 else
|
|
|
4105 result = "None";
|
|
|
4106 return result;
|
|
|
4107 }
|
|
|
4108
|
|
|
4109 //=== VK_NV_cluster_acceleration_structure ===
|
|
|
4110
|
|
|
4111 VULKAN_HPP_INLINE std::string to_string( ClusterAccelerationStructureClusterFlagsNV value )
|
|
|
4112 {
|
|
|
4113 std::string result = "{";
|
|
|
4114 if ( value & ClusterAccelerationStructureClusterFlagBitsNV::eAllowDisableOpacityMicromaps )
|
|
|
4115 result += " AllowDisableOpacityMicromaps |";
|
|
|
4116
|
|
|
4117 if ( result.size() > 1 )
|
|
|
4118 result.back() = '}';
|
|
|
4119 else
|
|
|
4120 result = "{}";
|
|
|
4121 return result;
|
|
|
4122 }
|
|
|
4123
|
|
|
4124 VULKAN_HPP_INLINE std::string to_string( ClusterAccelerationStructureGeometryFlagsNV value )
|
|
|
4125 {
|
|
|
4126 std::string result = "{";
|
|
|
4127 if ( value & ClusterAccelerationStructureGeometryFlagBitsNV::eCullDisable )
|
|
|
4128 result += " CullDisable |";
|
|
|
4129 if ( value & ClusterAccelerationStructureGeometryFlagBitsNV::eNoDuplicateAnyhitInvocation )
|
|
|
4130 result += " NoDuplicateAnyhitInvocation |";
|
|
|
4131 if ( value & ClusterAccelerationStructureGeometryFlagBitsNV::eOpaque )
|
|
|
4132 result += " Opaque |";
|
|
|
4133
|
|
|
4134 if ( result.size() > 1 )
|
|
|
4135 result.back() = '}';
|
|
|
4136 else
|
|
|
4137 result = "{}";
|
|
|
4138 return result;
|
|
|
4139 }
|
|
|
4140
|
|
|
4141 VULKAN_HPP_INLINE std::string to_string( ClusterAccelerationStructureAddressResolutionFlagsNV value )
|
|
|
4142 {
|
|
|
4143 std::string result = "{";
|
|
|
4144 if ( value & ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedDstImplicitData )
|
|
|
4145 result += " IndirectedDstImplicitData |";
|
|
|
4146 if ( value & ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedScratchData )
|
|
|
4147 result += " IndirectedScratchData |";
|
|
|
4148 if ( value & ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedDstAddressArray )
|
|
|
4149 result += " IndirectedDstAddressArray |";
|
|
|
4150 if ( value & ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedDstSizesArray )
|
|
|
4151 result += " IndirectedDstSizesArray |";
|
|
|
4152 if ( value & ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedSrcInfosArray )
|
|
|
4153 result += " IndirectedSrcInfosArray |";
|
|
|
4154 if ( value & ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedSrcInfosCount )
|
|
|
4155 result += " IndirectedSrcInfosCount |";
|
|
|
4156
|
|
|
4157 if ( result.size() > 1 )
|
|
|
4158 result.back() = '}';
|
|
|
4159 else
|
|
|
4160 result = "None";
|
|
|
4161 return result;
|
|
|
4162 }
|
|
|
4163
|
|
|
4164 VULKAN_HPP_INLINE std::string to_string( ClusterAccelerationStructureIndexFormatFlagsNV value )
|
|
|
4165 {
|
|
|
4166 std::string result = "{";
|
|
|
4167 if ( value & ClusterAccelerationStructureIndexFormatFlagBitsNV::e8 )
|
|
|
4168 result += " 8 |";
|
|
|
4169 if ( value & ClusterAccelerationStructureIndexFormatFlagBitsNV::e16 )
|
|
|
4170 result += " 16 |";
|
|
|
4171 if ( value & ClusterAccelerationStructureIndexFormatFlagBitsNV::e32 )
|
|
|
4172 result += " 32 |";
|
|
|
4173
|
|
|
4174 if ( result.size() > 1 )
|
|
|
4175 result.back() = '}';
|
|
|
4176 else
|
|
|
4177 result = "{}";
|
|
|
4178 return result;
|
|
|
4179 }
|
|
|
4180
|
|
|
4181 //=== VK_NV_partitioned_acceleration_structure ===
|
|
|
4182
|
|
|
4183 VULKAN_HPP_INLINE std::string to_string( PartitionedAccelerationStructureInstanceFlagsNV value )
|
|
|
4184 {
|
|
|
4185 std::string result = "{";
|
|
|
4186 if ( value & PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagTriangleFacingCullDisable )
|
|
|
4187 result += " FlagTriangleFacingCullDisable |";
|
|
|
4188 if ( value & PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagTriangleFlipFacing )
|
|
|
4189 result += " FlagTriangleFlipFacing |";
|
|
|
4190 if ( value & PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagForceOpaque )
|
|
|
4191 result += " FlagForceOpaque |";
|
|
|
4192 if ( value & PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagForceNoOpaque )
|
|
|
4193 result += " FlagForceNoOpaque |";
|
|
|
4194 if ( value & PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagEnableExplicitBoundingBox )
|
|
|
4195 result += " FlagEnableExplicitBoundingBox |";
|
|
|
4196
|
|
|
4197 if ( result.size() > 1 )
|
|
|
4198 result.back() = '}';
|
|
|
4199 else
|
|
|
4200 result = "{}";
|
|
|
4201 return result;
|
|
|
4202 }
|
|
|
4203
|
|
|
4204 //=== VK_EXT_device_generated_commands ===
|
|
|
4205
|
|
|
4206 VULKAN_HPP_INLINE std::string to_string( IndirectCommandsLayoutUsageFlagsEXT value )
|
|
|
4207 {
|
|
|
4208 std::string result = "{";
|
|
|
4209 if ( value & IndirectCommandsLayoutUsageFlagBitsEXT::eExplicitPreprocess )
|
|
|
4210 result += " ExplicitPreprocess |";
|
|
|
4211 if ( value & IndirectCommandsLayoutUsageFlagBitsEXT::eUnorderedSequences )
|
|
|
4212 result += " UnorderedSequences |";
|
|
|
4213
|
|
|
4214 if ( result.size() > 1 )
|
|
|
4215 result.back() = '}';
|
|
|
4216 else
|
|
|
4217 result = "{}";
|
|
|
4218 return result;
|
|
|
4219 }
|
|
|
4220
|
|
|
4221 VULKAN_HPP_INLINE std::string to_string( IndirectCommandsInputModeFlagsEXT value )
|
|
|
4222 {
|
|
|
4223 std::string result = "{";
|
|
|
4224 if ( value & IndirectCommandsInputModeFlagBitsEXT::eVulkanIndexBuffer )
|
|
|
4225 result += " VulkanIndexBuffer |";
|
|
|
4226 if ( value & IndirectCommandsInputModeFlagBitsEXT::eDxgiIndexBuffer )
|
|
|
4227 result += " DxgiIndexBuffer |";
|
|
|
4228
|
|
|
4229 if ( result.size() > 1 )
|
|
|
4230 result.back() = '}';
|
|
|
4231 else
|
|
|
4232 result = "{}";
|
|
|
4233 return result;
|
|
|
4234 }
|
|
|
4235
|
|
|
4236 //=== VK_KHR_maintenance8 ===
|
|
|
4237
|
|
|
4238 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccessFlags3KHR )
|
|
|
4239 {
|
|
|
4240 return "None";
|
|
|
4241 }
|
|
|
4242
|
|
|
4243 #if defined( VK_USE_PLATFORM_OHOS )
|
|
|
4244 //=== VK_OHOS_surface ===
|
|
|
4245
|
|
|
4246 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SurfaceCreateFlagsOHOS )
|
|
|
4247 {
|
|
|
4248 return "{}";
|
|
|
4249 }
|
|
|
4250 #endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
4251
|
|
|
4252 #if defined( VK_USE_PLATFORM_OHOS )
|
|
|
4253 //=== VK_OHOS_native_buffer ===
|
|
|
4254
|
|
|
4255 VULKAN_HPP_INLINE std::string to_string( SwapchainImageUsageFlagsOHOS value )
|
|
|
4256 {
|
|
|
4257 std::string result = "{";
|
|
|
4258 if ( value & SwapchainImageUsageFlagBitsOHOS::eShared )
|
|
|
4259 result += " Shared |";
|
|
|
4260
|
|
|
4261 if ( result.size() > 1 )
|
|
|
4262 result.back() = '}';
|
|
|
4263 else
|
|
|
4264 result = "{}";
|
|
|
4265 return result;
|
|
|
4266 }
|
|
|
4267 #endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
4268
|
|
|
4269 //=== VK_ARM_performance_counters_by_region ===
|
|
|
4270
|
|
|
4271 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceCounterDescriptionFlagsARM )
|
|
|
4272 {
|
|
|
4273 return "{}";
|
|
|
4274 }
|
|
|
4275
|
|
|
4276 //=== VK_KHR_maintenance10 ===
|
|
|
4277
|
|
|
4278 VULKAN_HPP_INLINE std::string to_string( RenderingAttachmentFlagsKHR value )
|
|
|
4279 {
|
|
|
4280 std::string result = "{";
|
|
|
4281 if ( value & RenderingAttachmentFlagBitsKHR::eInputAttachmentFeedback )
|
|
|
4282 result += " InputAttachmentFeedback |";
|
|
|
4283 if ( value & RenderingAttachmentFlagBitsKHR::eResolveSkipTransferFunction )
|
|
|
4284 result += " ResolveSkipTransferFunction |";
|
|
|
4285 if ( value & RenderingAttachmentFlagBitsKHR::eResolveEnableTransferFunction )
|
|
|
4286 result += " ResolveEnableTransferFunction |";
|
|
|
4287
|
|
|
4288 if ( result.size() > 1 )
|
|
|
4289 result.back() = '}';
|
|
|
4290 else
|
|
|
4291 result = "{}";
|
|
|
4292 return result;
|
|
|
4293 }
|
|
|
4294
|
|
|
4295 VULKAN_HPP_INLINE std::string to_string( ResolveImageFlagsKHR value )
|
|
|
4296 {
|
|
|
4297 std::string result = "{";
|
|
|
4298 if ( value & ResolveImageFlagBitsKHR::eSkipTransferFunction )
|
|
|
4299 result += " SkipTransferFunction |";
|
|
|
4300 if ( value & ResolveImageFlagBitsKHR::eEnableTransferFunction )
|
|
|
4301 result += " EnableTransferFunction |";
|
|
|
4302
|
|
|
4303 if ( result.size() > 1 )
|
|
|
4304 result.back() = '}';
|
|
|
4305 else
|
|
|
4306 result = "{}";
|
|
|
4307 return result;
|
|
|
4308 }
|
|
|
4309
|
|
|
4310 //=======================
|
|
|
4311 //=== ENUMs to_string ===
|
|
|
4312 //=======================
|
|
|
4313
|
|
|
4314 VULKAN_HPP_INLINE std::string toHexString( uint32_t value )
|
|
|
4315 {
|
|
|
4316 #if __cpp_lib_format
|
|
|
4317 return std::format( "{:x}", value );
|
|
|
4318 #else
|
|
|
4319 std::stringstream stream;
|
|
|
4320 stream << std::hex << value;
|
|
|
4321 return stream.str();
|
|
|
4322 #endif
|
|
|
4323 }
|
|
|
4324
|
|
|
4325 //=== VK_VERSION_1_0 ===
|
|
|
4326
|
|
|
4327 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( Result value )
|
|
|
4328 {
|
|
|
4329 switch ( value )
|
|
|
4330 {
|
|
|
4331 case Result::eSuccess : return "Success";
|
|
|
4332 case Result::eNotReady : return "NotReady";
|
|
|
4333 case Result::eTimeout : return "Timeout";
|
|
|
4334 case Result::eEventSet : return "EventSet";
|
|
|
4335 case Result::eEventReset : return "EventReset";
|
|
|
4336 case Result::eIncomplete : return "Incomplete";
|
|
|
4337 case Result::eErrorOutOfHostMemory : return "ErrorOutOfHostMemory";
|
|
|
4338 case Result::eErrorOutOfDeviceMemory : return "ErrorOutOfDeviceMemory";
|
|
|
4339 case Result::eErrorInitializationFailed : return "ErrorInitializationFailed";
|
|
|
4340 case Result::eErrorDeviceLost : return "ErrorDeviceLost";
|
|
|
4341 case Result::eErrorMemoryMapFailed : return "ErrorMemoryMapFailed";
|
|
|
4342 case Result::eErrorLayerNotPresent : return "ErrorLayerNotPresent";
|
|
|
4343 case Result::eErrorExtensionNotPresent : return "ErrorExtensionNotPresent";
|
|
|
4344 case Result::eErrorFeatureNotPresent : return "ErrorFeatureNotPresent";
|
|
|
4345 case Result::eErrorIncompatibleDriver : return "ErrorIncompatibleDriver";
|
|
|
4346 case Result::eErrorTooManyObjects : return "ErrorTooManyObjects";
|
|
|
4347 case Result::eErrorFormatNotSupported : return "ErrorFormatNotSupported";
|
|
|
4348 case Result::eErrorFragmentedPool : return "ErrorFragmentedPool";
|
|
|
4349 case Result::eErrorUnknown : return "ErrorUnknown";
|
|
|
4350 case Result::eErrorValidationFailed : return "ErrorValidationFailed";
|
|
|
4351 case Result::eErrorOutOfPoolMemory : return "ErrorOutOfPoolMemory";
|
|
|
4352 case Result::eErrorInvalidExternalHandle : return "ErrorInvalidExternalHandle";
|
|
|
4353 case Result::eErrorInvalidOpaqueCaptureAddress : return "ErrorInvalidOpaqueCaptureAddress";
|
|
|
4354 case Result::eErrorFragmentation : return "ErrorFragmentation";
|
|
|
4355 case Result::ePipelineCompileRequired : return "PipelineCompileRequired";
|
|
|
4356 case Result::eErrorNotPermitted : return "ErrorNotPermitted";
|
|
|
4357 case Result::eErrorSurfaceLostKHR : return "ErrorSurfaceLostKHR";
|
|
|
4358 case Result::eErrorNativeWindowInUseKHR : return "ErrorNativeWindowInUseKHR";
|
|
|
4359 case Result::eSuboptimalKHR : return "SuboptimalKHR";
|
|
|
4360 case Result::eErrorOutOfDateKHR : return "ErrorOutOfDateKHR";
|
|
|
4361 case Result::eErrorIncompatibleDisplayKHR : return "ErrorIncompatibleDisplayKHR";
|
|
|
4362 case Result::eErrorInvalidShaderNV : return "ErrorInvalidShaderNV";
|
|
|
4363 case Result::eErrorImageUsageNotSupportedKHR : return "ErrorImageUsageNotSupportedKHR";
|
|
|
4364 case Result::eErrorVideoPictureLayoutNotSupportedKHR : return "ErrorVideoPictureLayoutNotSupportedKHR";
|
|
|
4365 case Result::eErrorVideoProfileOperationNotSupportedKHR : return "ErrorVideoProfileOperationNotSupportedKHR";
|
|
|
4366 case Result::eErrorVideoProfileFormatNotSupportedKHR : return "ErrorVideoProfileFormatNotSupportedKHR";
|
|
|
4367 case Result::eErrorVideoProfileCodecNotSupportedKHR : return "ErrorVideoProfileCodecNotSupportedKHR";
|
|
|
4368 case Result::eErrorVideoStdVersionNotSupportedKHR : return "ErrorVideoStdVersionNotSupportedKHR";
|
|
|
4369 case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: return "ErrorInvalidDrmFormatModifierPlaneLayoutEXT";
|
|
|
4370 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
4371 case Result::eErrorFullScreenExclusiveModeLostEXT: return "ErrorFullScreenExclusiveModeLostEXT";
|
|
|
4372 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
4373 case Result::eThreadIdleKHR : return "ThreadIdleKHR";
|
|
|
4374 case Result::eThreadDoneKHR : return "ThreadDoneKHR";
|
|
|
4375 case Result::eOperationDeferredKHR : return "OperationDeferredKHR";
|
|
|
4376 case Result::eOperationNotDeferredKHR : return "OperationNotDeferredKHR";
|
|
|
4377 case Result::eErrorInvalidVideoStdParametersKHR: return "ErrorInvalidVideoStdParametersKHR";
|
|
|
4378 case Result::eErrorCompressionExhaustedEXT : return "ErrorCompressionExhaustedEXT";
|
|
|
4379 case Result::eIncompatibleShaderBinaryEXT : return "IncompatibleShaderBinaryEXT";
|
|
|
4380 case Result::ePipelineBinaryMissingKHR : return "PipelineBinaryMissingKHR";
|
|
|
4381 case Result::eErrorNotEnoughSpaceKHR : return "ErrorNotEnoughSpaceKHR";
|
|
|
4382 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
4383 }
|
|
|
4384 }
|
|
|
4385
|
|
|
4386 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( StructureType value )
|
|
|
4387 {
|
|
|
4388 switch ( value )
|
|
|
4389 {
|
|
|
4390 case StructureType::eApplicationInfo : return "ApplicationInfo";
|
|
|
4391 case StructureType::eInstanceCreateInfo : return "InstanceCreateInfo";
|
|
|
4392 case StructureType::eDeviceQueueCreateInfo : return "DeviceQueueCreateInfo";
|
|
|
4393 case StructureType::eDeviceCreateInfo : return "DeviceCreateInfo";
|
|
|
4394 case StructureType::eSubmitInfo : return "SubmitInfo";
|
|
|
4395 case StructureType::eMemoryAllocateInfo : return "MemoryAllocateInfo";
|
|
|
4396 case StructureType::eMappedMemoryRange : return "MappedMemoryRange";
|
|
|
4397 case StructureType::eBindSparseInfo : return "BindSparseInfo";
|
|
|
4398 case StructureType::eFenceCreateInfo : return "FenceCreateInfo";
|
|
|
4399 case StructureType::eSemaphoreCreateInfo : return "SemaphoreCreateInfo";
|
|
|
4400 case StructureType::eEventCreateInfo : return "EventCreateInfo";
|
|
|
4401 case StructureType::eQueryPoolCreateInfo : return "QueryPoolCreateInfo";
|
|
|
4402 case StructureType::eBufferCreateInfo : return "BufferCreateInfo";
|
|
|
4403 case StructureType::eBufferViewCreateInfo : return "BufferViewCreateInfo";
|
|
|
4404 case StructureType::eImageCreateInfo : return "ImageCreateInfo";
|
|
|
4405 case StructureType::eImageViewCreateInfo : return "ImageViewCreateInfo";
|
|
|
4406 case StructureType::eShaderModuleCreateInfo : return "ShaderModuleCreateInfo";
|
|
|
4407 case StructureType::ePipelineCacheCreateInfo : return "PipelineCacheCreateInfo";
|
|
|
4408 case StructureType::ePipelineShaderStageCreateInfo : return "PipelineShaderStageCreateInfo";
|
|
|
4409 case StructureType::ePipelineVertexInputStateCreateInfo : return "PipelineVertexInputStateCreateInfo";
|
|
|
4410 case StructureType::ePipelineInputAssemblyStateCreateInfo : return "PipelineInputAssemblyStateCreateInfo";
|
|
|
4411 case StructureType::ePipelineTessellationStateCreateInfo : return "PipelineTessellationStateCreateInfo";
|
|
|
4412 case StructureType::ePipelineViewportStateCreateInfo : return "PipelineViewportStateCreateInfo";
|
|
|
4413 case StructureType::ePipelineRasterizationStateCreateInfo : return "PipelineRasterizationStateCreateInfo";
|
|
|
4414 case StructureType::ePipelineMultisampleStateCreateInfo : return "PipelineMultisampleStateCreateInfo";
|
|
|
4415 case StructureType::ePipelineDepthStencilStateCreateInfo : return "PipelineDepthStencilStateCreateInfo";
|
|
|
4416 case StructureType::ePipelineColorBlendStateCreateInfo : return "PipelineColorBlendStateCreateInfo";
|
|
|
4417 case StructureType::ePipelineDynamicStateCreateInfo : return "PipelineDynamicStateCreateInfo";
|
|
|
4418 case StructureType::eGraphicsPipelineCreateInfo : return "GraphicsPipelineCreateInfo";
|
|
|
4419 case StructureType::eComputePipelineCreateInfo : return "ComputePipelineCreateInfo";
|
|
|
4420 case StructureType::ePipelineLayoutCreateInfo : return "PipelineLayoutCreateInfo";
|
|
|
4421 case StructureType::eSamplerCreateInfo : return "SamplerCreateInfo";
|
|
|
4422 case StructureType::eDescriptorSetLayoutCreateInfo : return "DescriptorSetLayoutCreateInfo";
|
|
|
4423 case StructureType::eDescriptorPoolCreateInfo : return "DescriptorPoolCreateInfo";
|
|
|
4424 case StructureType::eDescriptorSetAllocateInfo : return "DescriptorSetAllocateInfo";
|
|
|
4425 case StructureType::eWriteDescriptorSet : return "WriteDescriptorSet";
|
|
|
4426 case StructureType::eCopyDescriptorSet : return "CopyDescriptorSet";
|
|
|
4427 case StructureType::eFramebufferCreateInfo : return "FramebufferCreateInfo";
|
|
|
4428 case StructureType::eRenderPassCreateInfo : return "RenderPassCreateInfo";
|
|
|
4429 case StructureType::eCommandPoolCreateInfo : return "CommandPoolCreateInfo";
|
|
|
4430 case StructureType::eCommandBufferAllocateInfo : return "CommandBufferAllocateInfo";
|
|
|
4431 case StructureType::eCommandBufferInheritanceInfo : return "CommandBufferInheritanceInfo";
|
|
|
4432 case StructureType::eCommandBufferBeginInfo : return "CommandBufferBeginInfo";
|
|
|
4433 case StructureType::eRenderPassBeginInfo : return "RenderPassBeginInfo";
|
|
|
4434 case StructureType::eBufferMemoryBarrier : return "BufferMemoryBarrier";
|
|
|
4435 case StructureType::eImageMemoryBarrier : return "ImageMemoryBarrier";
|
|
|
4436 case StructureType::eMemoryBarrier : return "MemoryBarrier";
|
|
|
4437 case StructureType::eLoaderInstanceCreateInfo : return "LoaderInstanceCreateInfo";
|
|
|
4438 case StructureType::eLoaderDeviceCreateInfo : return "LoaderDeviceCreateInfo";
|
|
|
4439 case StructureType::eBindBufferMemoryInfo : return "BindBufferMemoryInfo";
|
|
|
4440 case StructureType::eBindImageMemoryInfo : return "BindImageMemoryInfo";
|
|
|
4441 case StructureType::eMemoryDedicatedRequirements : return "MemoryDedicatedRequirements";
|
|
|
4442 case StructureType::eMemoryDedicatedAllocateInfo : return "MemoryDedicatedAllocateInfo";
|
|
|
4443 case StructureType::eMemoryAllocateFlagsInfo : return "MemoryAllocateFlagsInfo";
|
|
|
4444 case StructureType::eDeviceGroupCommandBufferBeginInfo : return "DeviceGroupCommandBufferBeginInfo";
|
|
|
4445 case StructureType::eDeviceGroupSubmitInfo : return "DeviceGroupSubmitInfo";
|
|
|
4446 case StructureType::eDeviceGroupBindSparseInfo : return "DeviceGroupBindSparseInfo";
|
|
|
4447 case StructureType::eBindBufferMemoryDeviceGroupInfo : return "BindBufferMemoryDeviceGroupInfo";
|
|
|
4448 case StructureType::eBindImageMemoryDeviceGroupInfo : return "BindImageMemoryDeviceGroupInfo";
|
|
|
4449 case StructureType::ePhysicalDeviceGroupProperties : return "PhysicalDeviceGroupProperties";
|
|
|
4450 case StructureType::eDeviceGroupDeviceCreateInfo : return "DeviceGroupDeviceCreateInfo";
|
|
|
4451 case StructureType::eBufferMemoryRequirementsInfo2 : return "BufferMemoryRequirementsInfo2";
|
|
|
4452 case StructureType::eImageMemoryRequirementsInfo2 : return "ImageMemoryRequirementsInfo2";
|
|
|
4453 case StructureType::eImageSparseMemoryRequirementsInfo2 : return "ImageSparseMemoryRequirementsInfo2";
|
|
|
4454 case StructureType::eMemoryRequirements2 : return "MemoryRequirements2";
|
|
|
4455 case StructureType::eSparseImageMemoryRequirements2 : return "SparseImageMemoryRequirements2";
|
|
|
4456 case StructureType::ePhysicalDeviceFeatures2 : return "PhysicalDeviceFeatures2";
|
|
|
4457 case StructureType::ePhysicalDeviceProperties2 : return "PhysicalDeviceProperties2";
|
|
|
4458 case StructureType::eFormatProperties2 : return "FormatProperties2";
|
|
|
4459 case StructureType::eImageFormatProperties2 : return "ImageFormatProperties2";
|
|
|
4460 case StructureType::ePhysicalDeviceImageFormatInfo2 : return "PhysicalDeviceImageFormatInfo2";
|
|
|
4461 case StructureType::eQueueFamilyProperties2 : return "QueueFamilyProperties2";
|
|
|
4462 case StructureType::ePhysicalDeviceMemoryProperties2 : return "PhysicalDeviceMemoryProperties2";
|
|
|
4463 case StructureType::eSparseImageFormatProperties2 : return "SparseImageFormatProperties2";
|
|
|
4464 case StructureType::ePhysicalDeviceSparseImageFormatInfo2 : return "PhysicalDeviceSparseImageFormatInfo2";
|
|
|
4465 case StructureType::eImageViewUsageCreateInfo : return "ImageViewUsageCreateInfo";
|
|
|
4466 case StructureType::eProtectedSubmitInfo : return "ProtectedSubmitInfo";
|
|
|
4467 case StructureType::ePhysicalDeviceProtectedMemoryFeatures : return "PhysicalDeviceProtectedMemoryFeatures";
|
|
|
4468 case StructureType::ePhysicalDeviceProtectedMemoryProperties : return "PhysicalDeviceProtectedMemoryProperties";
|
|
|
4469 case StructureType::eDeviceQueueInfo2 : return "DeviceQueueInfo2";
|
|
|
4470 case StructureType::ePhysicalDeviceExternalImageFormatInfo : return "PhysicalDeviceExternalImageFormatInfo";
|
|
|
4471 case StructureType::eExternalImageFormatProperties : return "ExternalImageFormatProperties";
|
|
|
4472 case StructureType::ePhysicalDeviceExternalBufferInfo : return "PhysicalDeviceExternalBufferInfo";
|
|
|
4473 case StructureType::eExternalBufferProperties : return "ExternalBufferProperties";
|
|
|
4474 case StructureType::ePhysicalDeviceIdProperties : return "PhysicalDeviceIdProperties";
|
|
|
4475 case StructureType::eExternalMemoryBufferCreateInfo : return "ExternalMemoryBufferCreateInfo";
|
|
|
4476 case StructureType::eExternalMemoryImageCreateInfo : return "ExternalMemoryImageCreateInfo";
|
|
|
4477 case StructureType::eExportMemoryAllocateInfo : return "ExportMemoryAllocateInfo";
|
|
|
4478 case StructureType::ePhysicalDeviceExternalFenceInfo : return "PhysicalDeviceExternalFenceInfo";
|
|
|
4479 case StructureType::eExternalFenceProperties : return "ExternalFenceProperties";
|
|
|
4480 case StructureType::eExportFenceCreateInfo : return "ExportFenceCreateInfo";
|
|
|
4481 case StructureType::eExportSemaphoreCreateInfo : return "ExportSemaphoreCreateInfo";
|
|
|
4482 case StructureType::ePhysicalDeviceExternalSemaphoreInfo : return "PhysicalDeviceExternalSemaphoreInfo";
|
|
|
4483 case StructureType::eExternalSemaphoreProperties : return "ExternalSemaphoreProperties";
|
|
|
4484 case StructureType::ePhysicalDeviceSubgroupProperties : return "PhysicalDeviceSubgroupProperties";
|
|
|
4485 case StructureType::ePhysicalDevice16BitStorageFeatures : return "PhysicalDevice16BitStorageFeatures";
|
|
|
4486 case StructureType::ePhysicalDeviceVariablePointersFeatures : return "PhysicalDeviceVariablePointersFeatures";
|
|
|
4487 case StructureType::eDescriptorUpdateTemplateCreateInfo : return "DescriptorUpdateTemplateCreateInfo";
|
|
|
4488 case StructureType::ePhysicalDeviceMaintenance3Properties : return "PhysicalDeviceMaintenance3Properties";
|
|
|
4489 case StructureType::eDescriptorSetLayoutSupport : return "DescriptorSetLayoutSupport";
|
|
|
4490 case StructureType::eSamplerYcbcrConversionCreateInfo : return "SamplerYcbcrConversionCreateInfo";
|
|
|
4491 case StructureType::eSamplerYcbcrConversionInfo : return "SamplerYcbcrConversionInfo";
|
|
|
4492 case StructureType::eBindImagePlaneMemoryInfo : return "BindImagePlaneMemoryInfo";
|
|
|
4493 case StructureType::eImagePlaneMemoryRequirementsInfo : return "ImagePlaneMemoryRequirementsInfo";
|
|
|
4494 case StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures : return "PhysicalDeviceSamplerYcbcrConversionFeatures";
|
|
|
4495 case StructureType::eSamplerYcbcrConversionImageFormatProperties : return "SamplerYcbcrConversionImageFormatProperties";
|
|
|
4496 case StructureType::eDeviceGroupRenderPassBeginInfo : return "DeviceGroupRenderPassBeginInfo";
|
|
|
4497 case StructureType::ePhysicalDevicePointClippingProperties : return "PhysicalDevicePointClippingProperties";
|
|
|
4498 case StructureType::eRenderPassInputAttachmentAspectCreateInfo : return "RenderPassInputAttachmentAspectCreateInfo";
|
|
|
4499 case StructureType::ePipelineTessellationDomainOriginStateCreateInfo : return "PipelineTessellationDomainOriginStateCreateInfo";
|
|
|
4500 case StructureType::eRenderPassMultiviewCreateInfo : return "RenderPassMultiviewCreateInfo";
|
|
|
4501 case StructureType::ePhysicalDeviceMultiviewFeatures : return "PhysicalDeviceMultiviewFeatures";
|
|
|
4502 case StructureType::ePhysicalDeviceMultiviewProperties : return "PhysicalDeviceMultiviewProperties";
|
|
|
4503 case StructureType::ePhysicalDeviceShaderDrawParametersFeatures : return "PhysicalDeviceShaderDrawParametersFeatures";
|
|
|
4504 case StructureType::ePhysicalDeviceVulkan11Features : return "PhysicalDeviceVulkan11Features";
|
|
|
4505 case StructureType::ePhysicalDeviceVulkan11Properties : return "PhysicalDeviceVulkan11Properties";
|
|
|
4506 case StructureType::ePhysicalDeviceVulkan12Features : return "PhysicalDeviceVulkan12Features";
|
|
|
4507 case StructureType::ePhysicalDeviceVulkan12Properties : return "PhysicalDeviceVulkan12Properties";
|
|
|
4508 case StructureType::eImageFormatListCreateInfo : return "ImageFormatListCreateInfo";
|
|
|
4509 case StructureType::ePhysicalDeviceDriverProperties : return "PhysicalDeviceDriverProperties";
|
|
|
4510 case StructureType::ePhysicalDeviceVulkanMemoryModelFeatures : return "PhysicalDeviceVulkanMemoryModelFeatures";
|
|
|
4511 case StructureType::ePhysicalDeviceHostQueryResetFeatures : return "PhysicalDeviceHostQueryResetFeatures";
|
|
|
4512 case StructureType::ePhysicalDeviceTimelineSemaphoreFeatures : return "PhysicalDeviceTimelineSemaphoreFeatures";
|
|
|
4513 case StructureType::ePhysicalDeviceTimelineSemaphoreProperties : return "PhysicalDeviceTimelineSemaphoreProperties";
|
|
|
4514 case StructureType::eSemaphoreTypeCreateInfo : return "SemaphoreTypeCreateInfo";
|
|
|
4515 case StructureType::eTimelineSemaphoreSubmitInfo : return "TimelineSemaphoreSubmitInfo";
|
|
|
4516 case StructureType::eSemaphoreWaitInfo : return "SemaphoreWaitInfo";
|
|
|
4517 case StructureType::eSemaphoreSignalInfo : return "SemaphoreSignalInfo";
|
|
|
4518 case StructureType::ePhysicalDeviceBufferDeviceAddressFeatures : return "PhysicalDeviceBufferDeviceAddressFeatures";
|
|
|
4519 case StructureType::eBufferDeviceAddressInfo : return "BufferDeviceAddressInfo";
|
|
|
4520 case StructureType::eBufferOpaqueCaptureAddressCreateInfo : return "BufferOpaqueCaptureAddressCreateInfo";
|
|
|
4521 case StructureType::eMemoryOpaqueCaptureAddressAllocateInfo : return "MemoryOpaqueCaptureAddressAllocateInfo";
|
|
|
4522 case StructureType::eDeviceMemoryOpaqueCaptureAddressInfo : return "DeviceMemoryOpaqueCaptureAddressInfo";
|
|
|
4523 case StructureType::ePhysicalDevice8BitStorageFeatures : return "PhysicalDevice8BitStorageFeatures";
|
|
|
4524 case StructureType::ePhysicalDeviceShaderAtomicInt64Features : return "PhysicalDeviceShaderAtomicInt64Features";
|
|
|
4525 case StructureType::ePhysicalDeviceShaderFloat16Int8Features : return "PhysicalDeviceShaderFloat16Int8Features";
|
|
|
4526 case StructureType::ePhysicalDeviceFloatControlsProperties : return "PhysicalDeviceFloatControlsProperties";
|
|
|
4527 case StructureType::eDescriptorSetLayoutBindingFlagsCreateInfo : return "DescriptorSetLayoutBindingFlagsCreateInfo";
|
|
|
4528 case StructureType::ePhysicalDeviceDescriptorIndexingFeatures : return "PhysicalDeviceDescriptorIndexingFeatures";
|
|
|
4529 case StructureType::ePhysicalDeviceDescriptorIndexingProperties : return "PhysicalDeviceDescriptorIndexingProperties";
|
|
|
4530 case StructureType::eDescriptorSetVariableDescriptorCountAllocateInfo : return "DescriptorSetVariableDescriptorCountAllocateInfo";
|
|
|
4531 case StructureType::eDescriptorSetVariableDescriptorCountLayoutSupport : return "DescriptorSetVariableDescriptorCountLayoutSupport";
|
|
|
4532 case StructureType::ePhysicalDeviceScalarBlockLayoutFeatures : return "PhysicalDeviceScalarBlockLayoutFeatures";
|
|
|
4533 case StructureType::ePhysicalDeviceSamplerFilterMinmaxProperties : return "PhysicalDeviceSamplerFilterMinmaxProperties";
|
|
|
4534 case StructureType::eSamplerReductionModeCreateInfo : return "SamplerReductionModeCreateInfo";
|
|
|
4535 case StructureType::ePhysicalDeviceUniformBufferStandardLayoutFeatures : return "PhysicalDeviceUniformBufferStandardLayoutFeatures";
|
|
|
4536 case StructureType::ePhysicalDeviceShaderSubgroupExtendedTypesFeatures : return "PhysicalDeviceShaderSubgroupExtendedTypesFeatures";
|
|
|
4537 case StructureType::eAttachmentDescription2 : return "AttachmentDescription2";
|
|
|
4538 case StructureType::eAttachmentReference2 : return "AttachmentReference2";
|
|
|
4539 case StructureType::eSubpassDescription2 : return "SubpassDescription2";
|
|
|
4540 case StructureType::eSubpassDependency2 : return "SubpassDependency2";
|
|
|
4541 case StructureType::eRenderPassCreateInfo2 : return "RenderPassCreateInfo2";
|
|
|
4542 case StructureType::eSubpassBeginInfo : return "SubpassBeginInfo";
|
|
|
4543 case StructureType::eSubpassEndInfo : return "SubpassEndInfo";
|
|
|
4544 case StructureType::ePhysicalDeviceDepthStencilResolveProperties : return "PhysicalDeviceDepthStencilResolveProperties";
|
|
|
4545 case StructureType::eSubpassDescriptionDepthStencilResolve : return "SubpassDescriptionDepthStencilResolve";
|
|
|
4546 case StructureType::eImageStencilUsageCreateInfo : return "ImageStencilUsageCreateInfo";
|
|
|
4547 case StructureType::ePhysicalDeviceImagelessFramebufferFeatures : return "PhysicalDeviceImagelessFramebufferFeatures";
|
|
|
4548 case StructureType::eFramebufferAttachmentsCreateInfo : return "FramebufferAttachmentsCreateInfo";
|
|
|
4549 case StructureType::eFramebufferAttachmentImageInfo : return "FramebufferAttachmentImageInfo";
|
|
|
4550 case StructureType::eRenderPassAttachmentBeginInfo : return "RenderPassAttachmentBeginInfo";
|
|
|
4551 case StructureType::ePhysicalDeviceSeparateDepthStencilLayoutsFeatures : return "PhysicalDeviceSeparateDepthStencilLayoutsFeatures";
|
|
|
4552 case StructureType::eAttachmentReferenceStencilLayout : return "AttachmentReferenceStencilLayout";
|
|
|
4553 case StructureType::eAttachmentDescriptionStencilLayout : return "AttachmentDescriptionStencilLayout";
|
|
|
4554 case StructureType::ePhysicalDeviceVulkan13Features : return "PhysicalDeviceVulkan13Features";
|
|
|
4555 case StructureType::ePhysicalDeviceVulkan13Properties : return "PhysicalDeviceVulkan13Properties";
|
|
|
4556 case StructureType::ePhysicalDeviceToolProperties : return "PhysicalDeviceToolProperties";
|
|
|
4557 case StructureType::ePhysicalDevicePrivateDataFeatures : return "PhysicalDevicePrivateDataFeatures";
|
|
|
4558 case StructureType::eDevicePrivateDataCreateInfo : return "DevicePrivateDataCreateInfo";
|
|
|
4559 case StructureType::ePrivateDataSlotCreateInfo : return "PrivateDataSlotCreateInfo";
|
|
|
4560 case StructureType::eMemoryBarrier2 : return "MemoryBarrier2";
|
|
|
4561 case StructureType::eBufferMemoryBarrier2 : return "BufferMemoryBarrier2";
|
|
|
4562 case StructureType::eImageMemoryBarrier2 : return "ImageMemoryBarrier2";
|
|
|
4563 case StructureType::eDependencyInfo : return "DependencyInfo";
|
|
|
4564 case StructureType::eSubmitInfo2 : return "SubmitInfo2";
|
|
|
4565 case StructureType::eSemaphoreSubmitInfo : return "SemaphoreSubmitInfo";
|
|
|
4566 case StructureType::eCommandBufferSubmitInfo : return "CommandBufferSubmitInfo";
|
|
|
4567 case StructureType::ePhysicalDeviceSynchronization2Features : return "PhysicalDeviceSynchronization2Features";
|
|
|
4568 case StructureType::eCopyBufferInfo2 : return "CopyBufferInfo2";
|
|
|
4569 case StructureType::eCopyImageInfo2 : return "CopyImageInfo2";
|
|
|
4570 case StructureType::eCopyBufferToImageInfo2 : return "CopyBufferToImageInfo2";
|
|
|
4571 case StructureType::eCopyImageToBufferInfo2 : return "CopyImageToBufferInfo2";
|
|
|
4572 case StructureType::eBufferCopy2 : return "BufferCopy2";
|
|
|
4573 case StructureType::eImageCopy2 : return "ImageCopy2";
|
|
|
4574 case StructureType::eBufferImageCopy2 : return "BufferImageCopy2";
|
|
|
4575 case StructureType::ePhysicalDeviceTextureCompressionAstcHdrFeatures : return "PhysicalDeviceTextureCompressionAstcHdrFeatures";
|
|
|
4576 case StructureType::eFormatProperties3 : return "FormatProperties3";
|
|
|
4577 case StructureType::ePhysicalDeviceMaintenance4Features : return "PhysicalDeviceMaintenance4Features";
|
|
|
4578 case StructureType::ePhysicalDeviceMaintenance4Properties : return "PhysicalDeviceMaintenance4Properties";
|
|
|
4579 case StructureType::eDeviceBufferMemoryRequirements : return "DeviceBufferMemoryRequirements";
|
|
|
4580 case StructureType::eDeviceImageMemoryRequirements : return "DeviceImageMemoryRequirements";
|
|
|
4581 case StructureType::ePipelineCreationFeedbackCreateInfo : return "PipelineCreationFeedbackCreateInfo";
|
|
|
4582 case StructureType::ePhysicalDeviceShaderTerminateInvocationFeatures : return "PhysicalDeviceShaderTerminateInvocationFeatures";
|
|
|
4583 case StructureType::ePhysicalDeviceShaderDemoteToHelperInvocationFeatures: return "PhysicalDeviceShaderDemoteToHelperInvocationFeatures";
|
|
|
4584 case StructureType::ePhysicalDevicePipelineCreationCacheControlFeatures : return "PhysicalDevicePipelineCreationCacheControlFeatures";
|
|
|
4585 case StructureType::ePhysicalDeviceZeroInitializeWorkgroupMemoryFeatures : return "PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures";
|
|
|
4586 case StructureType::ePhysicalDeviceImageRobustnessFeatures : return "PhysicalDeviceImageRobustnessFeatures";
|
|
|
4587 case StructureType::ePhysicalDeviceSubgroupSizeControlProperties : return "PhysicalDeviceSubgroupSizeControlProperties";
|
|
|
4588 case StructureType::ePipelineShaderStageRequiredSubgroupSizeCreateInfo : return "PipelineShaderStageRequiredSubgroupSizeCreateInfo";
|
|
|
4589 case StructureType::ePhysicalDeviceSubgroupSizeControlFeatures : return "PhysicalDeviceSubgroupSizeControlFeatures";
|
|
|
4590 case StructureType::ePhysicalDeviceInlineUniformBlockFeatures : return "PhysicalDeviceInlineUniformBlockFeatures";
|
|
|
4591 case StructureType::ePhysicalDeviceInlineUniformBlockProperties : return "PhysicalDeviceInlineUniformBlockProperties";
|
|
|
4592 case StructureType::eWriteDescriptorSetInlineUniformBlock : return "WriteDescriptorSetInlineUniformBlock";
|
|
|
4593 case StructureType::eDescriptorPoolInlineUniformBlockCreateInfo : return "DescriptorPoolInlineUniformBlockCreateInfo";
|
|
|
4594 case StructureType::ePhysicalDeviceShaderIntegerDotProductFeatures : return "PhysicalDeviceShaderIntegerDotProductFeatures";
|
|
|
4595 case StructureType::ePhysicalDeviceShaderIntegerDotProductProperties : return "PhysicalDeviceShaderIntegerDotProductProperties";
|
|
|
4596 case StructureType::ePhysicalDeviceTexelBufferAlignmentProperties : return "PhysicalDeviceTexelBufferAlignmentProperties";
|
|
|
4597 case StructureType::eBlitImageInfo2 : return "BlitImageInfo2";
|
|
|
4598 case StructureType::eResolveImageInfo2 : return "ResolveImageInfo2";
|
|
|
4599 case StructureType::eImageBlit2 : return "ImageBlit2";
|
|
|
4600 case StructureType::eImageResolve2 : return "ImageResolve2";
|
|
|
4601 case StructureType::eRenderingInfo : return "RenderingInfo";
|
|
|
4602 case StructureType::eRenderingAttachmentInfo : return "RenderingAttachmentInfo";
|
|
|
4603 case StructureType::ePipelineRenderingCreateInfo : return "PipelineRenderingCreateInfo";
|
|
|
4604 case StructureType::ePhysicalDeviceDynamicRenderingFeatures : return "PhysicalDeviceDynamicRenderingFeatures";
|
|
|
4605 case StructureType::eCommandBufferInheritanceRenderingInfo : return "CommandBufferInheritanceRenderingInfo";
|
|
|
4606 case StructureType::ePhysicalDeviceVulkan14Features : return "PhysicalDeviceVulkan14Features";
|
|
|
4607 case StructureType::ePhysicalDeviceVulkan14Properties : return "PhysicalDeviceVulkan14Properties";
|
|
|
4608 case StructureType::eDeviceQueueGlobalPriorityCreateInfo : return "DeviceQueueGlobalPriorityCreateInfo";
|
|
|
4609 case StructureType::ePhysicalDeviceGlobalPriorityQueryFeatures : return "PhysicalDeviceGlobalPriorityQueryFeatures";
|
|
|
4610 case StructureType::eQueueFamilyGlobalPriorityProperties : return "QueueFamilyGlobalPriorityProperties";
|
|
|
4611 case StructureType::ePhysicalDeviceIndexTypeUint8Features : return "PhysicalDeviceIndexTypeUint8Features";
|
|
|
4612 case StructureType::eMemoryMapInfo : return "MemoryMapInfo";
|
|
|
4613 case StructureType::eMemoryUnmapInfo : return "MemoryUnmapInfo";
|
|
|
4614 case StructureType::ePhysicalDeviceMaintenance5Features : return "PhysicalDeviceMaintenance5Features";
|
|
|
4615 case StructureType::ePhysicalDeviceMaintenance5Properties : return "PhysicalDeviceMaintenance5Properties";
|
|
|
4616 case StructureType::eDeviceImageSubresourceInfo : return "DeviceImageSubresourceInfo";
|
|
|
4617 case StructureType::eSubresourceLayout2 : return "SubresourceLayout2";
|
|
|
4618 case StructureType::eImageSubresource2 : return "ImageSubresource2";
|
|
|
4619 case StructureType::eBufferUsageFlags2CreateInfo : return "BufferUsageFlags2CreateInfo";
|
|
|
4620 case StructureType::ePhysicalDeviceMaintenance6Features : return "PhysicalDeviceMaintenance6Features";
|
|
|
4621 case StructureType::ePhysicalDeviceMaintenance6Properties : return "PhysicalDeviceMaintenance6Properties";
|
|
|
4622 case StructureType::eBindMemoryStatus : return "BindMemoryStatus";
|
|
|
4623 case StructureType::ePhysicalDeviceHostImageCopyFeatures : return "PhysicalDeviceHostImageCopyFeatures";
|
|
|
4624 case StructureType::ePhysicalDeviceHostImageCopyProperties : return "PhysicalDeviceHostImageCopyProperties";
|
|
|
4625 case StructureType::eMemoryToImageCopy : return "MemoryToImageCopy";
|
|
|
4626 case StructureType::eImageToMemoryCopy : return "ImageToMemoryCopy";
|
|
|
4627 case StructureType::eCopyImageToMemoryInfo : return "CopyImageToMemoryInfo";
|
|
|
4628 case StructureType::eCopyMemoryToImageInfo : return "CopyMemoryToImageInfo";
|
|
|
4629 case StructureType::eHostImageLayoutTransitionInfo : return "HostImageLayoutTransitionInfo";
|
|
|
4630 case StructureType::eCopyImageToImageInfo : return "CopyImageToImageInfo";
|
|
|
4631 case StructureType::eSubresourceHostMemcpySize : return "SubresourceHostMemcpySize";
|
|
|
4632 case StructureType::eHostImageCopyDevicePerformanceQuery : return "HostImageCopyDevicePerformanceQuery";
|
|
|
4633 case StructureType::ePhysicalDeviceShaderSubgroupRotateFeatures : return "PhysicalDeviceShaderSubgroupRotateFeatures";
|
|
|
4634 case StructureType::ePhysicalDeviceShaderFloatControls2Features : return "PhysicalDeviceShaderFloatControls2Features";
|
|
|
4635 case StructureType::ePhysicalDeviceShaderExpectAssumeFeatures : return "PhysicalDeviceShaderExpectAssumeFeatures";
|
|
|
4636 case StructureType::ePipelineCreateFlags2CreateInfo : return "PipelineCreateFlags2CreateInfo";
|
|
|
4637 case StructureType::ePhysicalDevicePushDescriptorProperties : return "PhysicalDevicePushDescriptorProperties";
|
|
|
4638 case StructureType::eBindDescriptorSetsInfo : return "BindDescriptorSetsInfo";
|
|
|
4639 case StructureType::ePushConstantsInfo : return "PushConstantsInfo";
|
|
|
4640 case StructureType::ePushDescriptorSetInfo : return "PushDescriptorSetInfo";
|
|
|
4641 case StructureType::ePushDescriptorSetWithTemplateInfo : return "PushDescriptorSetWithTemplateInfo";
|
|
|
4642 case StructureType::ePhysicalDevicePipelineProtectedAccessFeatures : return "PhysicalDevicePipelineProtectedAccessFeatures";
|
|
|
4643 case StructureType::ePipelineRobustnessCreateInfo : return "PipelineRobustnessCreateInfo";
|
|
|
4644 case StructureType::ePhysicalDevicePipelineRobustnessFeatures : return "PhysicalDevicePipelineRobustnessFeatures";
|
|
|
4645 case StructureType::ePhysicalDevicePipelineRobustnessProperties : return "PhysicalDevicePipelineRobustnessProperties";
|
|
|
4646 case StructureType::ePhysicalDeviceLineRasterizationFeatures : return "PhysicalDeviceLineRasterizationFeatures";
|
|
|
4647 case StructureType::ePipelineRasterizationLineStateCreateInfo : return "PipelineRasterizationLineStateCreateInfo";
|
|
|
4648 case StructureType::ePhysicalDeviceLineRasterizationProperties : return "PhysicalDeviceLineRasterizationProperties";
|
|
|
4649 case StructureType::ePhysicalDeviceVertexAttributeDivisorProperties : return "PhysicalDeviceVertexAttributeDivisorProperties";
|
|
|
4650 case StructureType::ePipelineVertexInputDivisorStateCreateInfo : return "PipelineVertexInputDivisorStateCreateInfo";
|
|
|
4651 case StructureType::ePhysicalDeviceVertexAttributeDivisorFeatures : return "PhysicalDeviceVertexAttributeDivisorFeatures";
|
|
|
4652 case StructureType::eRenderingAreaInfo : return "RenderingAreaInfo";
|
|
|
4653 case StructureType::ePhysicalDeviceDynamicRenderingLocalReadFeatures : return "PhysicalDeviceDynamicRenderingLocalReadFeatures";
|
|
|
4654 case StructureType::eRenderingAttachmentLocationInfo : return "RenderingAttachmentLocationInfo";
|
|
|
4655 case StructureType::eRenderingInputAttachmentIndexInfo : return "RenderingInputAttachmentIndexInfo";
|
|
|
4656 case StructureType::eSwapchainCreateInfoKHR : return "SwapchainCreateInfoKHR";
|
|
|
4657 case StructureType::ePresentInfoKHR : return "PresentInfoKHR";
|
|
|
4658 case StructureType::eDeviceGroupPresentCapabilitiesKHR : return "DeviceGroupPresentCapabilitiesKHR";
|
|
|
4659 case StructureType::eImageSwapchainCreateInfoKHR : return "ImageSwapchainCreateInfoKHR";
|
|
|
4660 case StructureType::eBindImageMemorySwapchainInfoKHR : return "BindImageMemorySwapchainInfoKHR";
|
|
|
4661 case StructureType::eAcquireNextImageInfoKHR : return "AcquireNextImageInfoKHR";
|
|
|
4662 case StructureType::eDeviceGroupPresentInfoKHR : return "DeviceGroupPresentInfoKHR";
|
|
|
4663 case StructureType::eDeviceGroupSwapchainCreateInfoKHR : return "DeviceGroupSwapchainCreateInfoKHR";
|
|
|
4664 case StructureType::eDisplayModeCreateInfoKHR : return "DisplayModeCreateInfoKHR";
|
|
|
4665 case StructureType::eDisplaySurfaceCreateInfoKHR : return "DisplaySurfaceCreateInfoKHR";
|
|
|
4666 case StructureType::eDisplayPresentInfoKHR : return "DisplayPresentInfoKHR";
|
|
|
4667 #if defined( VK_USE_PLATFORM_XLIB_KHR )
|
|
|
4668 case StructureType::eXlibSurfaceCreateInfoKHR: return "XlibSurfaceCreateInfoKHR";
|
|
|
4669 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
|
|
|
4670 #if defined( VK_USE_PLATFORM_XCB_KHR )
|
|
|
4671 case StructureType::eXcbSurfaceCreateInfoKHR: return "XcbSurfaceCreateInfoKHR";
|
|
|
4672 #endif /*VK_USE_PLATFORM_XCB_KHR*/
|
|
|
4673 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
|
|
|
4674 case StructureType::eWaylandSurfaceCreateInfoKHR: return "WaylandSurfaceCreateInfoKHR";
|
|
|
4675 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
|
|
|
4676 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
|
4677 case StructureType::eAndroidSurfaceCreateInfoKHR: return "AndroidSurfaceCreateInfoKHR";
|
|
|
4678 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
4679 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
4680 case StructureType::eWin32SurfaceCreateInfoKHR: return "Win32SurfaceCreateInfoKHR";
|
|
|
4681 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
4682 case StructureType::eDebugReportCallbackCreateInfoEXT : return "DebugReportCallbackCreateInfoEXT";
|
|
|
4683 case StructureType::ePipelineRasterizationStateRasterizationOrderAMD: return "PipelineRasterizationStateRasterizationOrderAMD";
|
|
|
4684 case StructureType::eDebugMarkerObjectNameInfoEXT : return "DebugMarkerObjectNameInfoEXT";
|
|
|
4685 case StructureType::eDebugMarkerObjectTagInfoEXT : return "DebugMarkerObjectTagInfoEXT";
|
|
|
4686 case StructureType::eDebugMarkerMarkerInfoEXT : return "DebugMarkerMarkerInfoEXT";
|
|
|
4687 case StructureType::eVideoProfileInfoKHR : return "VideoProfileInfoKHR";
|
|
|
4688 case StructureType::eVideoCapabilitiesKHR : return "VideoCapabilitiesKHR";
|
|
|
4689 case StructureType::eVideoPictureResourceInfoKHR : return "VideoPictureResourceInfoKHR";
|
|
|
4690 case StructureType::eVideoSessionMemoryRequirementsKHR : return "VideoSessionMemoryRequirementsKHR";
|
|
|
4691 case StructureType::eBindVideoSessionMemoryInfoKHR : return "BindVideoSessionMemoryInfoKHR";
|
|
|
4692 case StructureType::eVideoSessionCreateInfoKHR : return "VideoSessionCreateInfoKHR";
|
|
|
4693 case StructureType::eVideoSessionParametersCreateInfoKHR : return "VideoSessionParametersCreateInfoKHR";
|
|
|
4694 case StructureType::eVideoSessionParametersUpdateInfoKHR : return "VideoSessionParametersUpdateInfoKHR";
|
|
|
4695 case StructureType::eVideoBeginCodingInfoKHR : return "VideoBeginCodingInfoKHR";
|
|
|
4696 case StructureType::eVideoEndCodingInfoKHR : return "VideoEndCodingInfoKHR";
|
|
|
4697 case StructureType::eVideoCodingControlInfoKHR : return "VideoCodingControlInfoKHR";
|
|
|
4698 case StructureType::eVideoReferenceSlotInfoKHR : return "VideoReferenceSlotInfoKHR";
|
|
|
4699 case StructureType::eQueueFamilyVideoPropertiesKHR : return "QueueFamilyVideoPropertiesKHR";
|
|
|
4700 case StructureType::eVideoProfileListInfoKHR : return "VideoProfileListInfoKHR";
|
|
|
4701 case StructureType::ePhysicalDeviceVideoFormatInfoKHR : return "PhysicalDeviceVideoFormatInfoKHR";
|
|
|
4702 case StructureType::eVideoFormatPropertiesKHR : return "VideoFormatPropertiesKHR";
|
|
|
4703 case StructureType::eQueueFamilyQueryResultStatusPropertiesKHR : return "QueueFamilyQueryResultStatusPropertiesKHR";
|
|
|
4704 case StructureType::eVideoDecodeInfoKHR : return "VideoDecodeInfoKHR";
|
|
|
4705 case StructureType::eVideoDecodeCapabilitiesKHR : return "VideoDecodeCapabilitiesKHR";
|
|
|
4706 case StructureType::eVideoDecodeUsageInfoKHR : return "VideoDecodeUsageInfoKHR";
|
|
|
4707 case StructureType::eDedicatedAllocationImageCreateInfoNV : return "DedicatedAllocationImageCreateInfoNV";
|
|
|
4708 case StructureType::eDedicatedAllocationBufferCreateInfoNV : return "DedicatedAllocationBufferCreateInfoNV";
|
|
|
4709 case StructureType::eDedicatedAllocationMemoryAllocateInfoNV : return "DedicatedAllocationMemoryAllocateInfoNV";
|
|
|
4710 case StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT : return "PhysicalDeviceTransformFeedbackFeaturesEXT";
|
|
|
4711 case StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT : return "PhysicalDeviceTransformFeedbackPropertiesEXT";
|
|
|
4712 case StructureType::ePipelineRasterizationStateStreamCreateInfoEXT : return "PipelineRasterizationStateStreamCreateInfoEXT";
|
|
|
4713 case StructureType::eCuModuleCreateInfoNVX : return "CuModuleCreateInfoNVX";
|
|
|
4714 case StructureType::eCuFunctionCreateInfoNVX : return "CuFunctionCreateInfoNVX";
|
|
|
4715 case StructureType::eCuLaunchInfoNVX : return "CuLaunchInfoNVX";
|
|
|
4716 case StructureType::eCuModuleTexturingModeCreateInfoNVX : return "CuModuleTexturingModeCreateInfoNVX";
|
|
|
4717 case StructureType::eImageViewHandleInfoNVX : return "ImageViewHandleInfoNVX";
|
|
|
4718 case StructureType::eImageViewAddressPropertiesNVX : return "ImageViewAddressPropertiesNVX";
|
|
|
4719 case StructureType::eVideoEncodeH264CapabilitiesKHR : return "VideoEncodeH264CapabilitiesKHR";
|
|
|
4720 case StructureType::eVideoEncodeH264SessionParametersCreateInfoKHR : return "VideoEncodeH264SessionParametersCreateInfoKHR";
|
|
|
4721 case StructureType::eVideoEncodeH264SessionParametersAddInfoKHR : return "VideoEncodeH264SessionParametersAddInfoKHR";
|
|
|
4722 case StructureType::eVideoEncodeH264PictureInfoKHR : return "VideoEncodeH264PictureInfoKHR";
|
|
|
4723 case StructureType::eVideoEncodeH264DpbSlotInfoKHR : return "VideoEncodeH264DpbSlotInfoKHR";
|
|
|
4724 case StructureType::eVideoEncodeH264NaluSliceInfoKHR : return "VideoEncodeH264NaluSliceInfoKHR";
|
|
|
4725 case StructureType::eVideoEncodeH264GopRemainingFrameInfoKHR : return "VideoEncodeH264GopRemainingFrameInfoKHR";
|
|
|
4726 case StructureType::eVideoEncodeH264ProfileInfoKHR : return "VideoEncodeH264ProfileInfoKHR";
|
|
|
4727 case StructureType::eVideoEncodeH264RateControlInfoKHR : return "VideoEncodeH264RateControlInfoKHR";
|
|
|
4728 case StructureType::eVideoEncodeH264RateControlLayerInfoKHR : return "VideoEncodeH264RateControlLayerInfoKHR";
|
|
|
4729 case StructureType::eVideoEncodeH264SessionCreateInfoKHR : return "VideoEncodeH264SessionCreateInfoKHR";
|
|
|
4730 case StructureType::eVideoEncodeH264QualityLevelPropertiesKHR : return "VideoEncodeH264QualityLevelPropertiesKHR";
|
|
|
4731 case StructureType::eVideoEncodeH264SessionParametersGetInfoKHR : return "VideoEncodeH264SessionParametersGetInfoKHR";
|
|
|
4732 case StructureType::eVideoEncodeH264SessionParametersFeedbackInfoKHR: return "VideoEncodeH264SessionParametersFeedbackInfoKHR";
|
|
|
4733 case StructureType::eVideoEncodeH265CapabilitiesKHR : return "VideoEncodeH265CapabilitiesKHR";
|
|
|
4734 case StructureType::eVideoEncodeH265SessionParametersCreateInfoKHR : return "VideoEncodeH265SessionParametersCreateInfoKHR";
|
|
|
4735 case StructureType::eVideoEncodeH265SessionParametersAddInfoKHR : return "VideoEncodeH265SessionParametersAddInfoKHR";
|
|
|
4736 case StructureType::eVideoEncodeH265PictureInfoKHR : return "VideoEncodeH265PictureInfoKHR";
|
|
|
4737 case StructureType::eVideoEncodeH265DpbSlotInfoKHR : return "VideoEncodeH265DpbSlotInfoKHR";
|
|
|
4738 case StructureType::eVideoEncodeH265NaluSliceSegmentInfoKHR : return "VideoEncodeH265NaluSliceSegmentInfoKHR";
|
|
|
4739 case StructureType::eVideoEncodeH265GopRemainingFrameInfoKHR : return "VideoEncodeH265GopRemainingFrameInfoKHR";
|
|
|
4740 case StructureType::eVideoEncodeH265ProfileInfoKHR : return "VideoEncodeH265ProfileInfoKHR";
|
|
|
4741 case StructureType::eVideoEncodeH265RateControlInfoKHR : return "VideoEncodeH265RateControlInfoKHR";
|
|
|
4742 case StructureType::eVideoEncodeH265RateControlLayerInfoKHR : return "VideoEncodeH265RateControlLayerInfoKHR";
|
|
|
4743 case StructureType::eVideoEncodeH265SessionCreateInfoKHR : return "VideoEncodeH265SessionCreateInfoKHR";
|
|
|
4744 case StructureType::eVideoEncodeH265QualityLevelPropertiesKHR : return "VideoEncodeH265QualityLevelPropertiesKHR";
|
|
|
4745 case StructureType::eVideoEncodeH265SessionParametersGetInfoKHR : return "VideoEncodeH265SessionParametersGetInfoKHR";
|
|
|
4746 case StructureType::eVideoEncodeH265SessionParametersFeedbackInfoKHR: return "VideoEncodeH265SessionParametersFeedbackInfoKHR";
|
|
|
4747 case StructureType::eVideoDecodeH264CapabilitiesKHR : return "VideoDecodeH264CapabilitiesKHR";
|
|
|
4748 case StructureType::eVideoDecodeH264PictureInfoKHR : return "VideoDecodeH264PictureInfoKHR";
|
|
|
4749 case StructureType::eVideoDecodeH264ProfileInfoKHR : return "VideoDecodeH264ProfileInfoKHR";
|
|
|
4750 case StructureType::eVideoDecodeH264SessionParametersCreateInfoKHR : return "VideoDecodeH264SessionParametersCreateInfoKHR";
|
|
|
4751 case StructureType::eVideoDecodeH264SessionParametersAddInfoKHR : return "VideoDecodeH264SessionParametersAddInfoKHR";
|
|
|
4752 case StructureType::eVideoDecodeH264DpbSlotInfoKHR : return "VideoDecodeH264DpbSlotInfoKHR";
|
|
|
4753 case StructureType::eTextureLodGatherFormatPropertiesAMD : return "TextureLodGatherFormatPropertiesAMD";
|
|
|
4754 #if defined( VK_USE_PLATFORM_GGP )
|
|
|
4755 case StructureType::eStreamDescriptorSurfaceCreateInfoGGP: return "StreamDescriptorSurfaceCreateInfoGGP";
|
|
|
4756 #endif /*VK_USE_PLATFORM_GGP*/
|
|
|
4757 case StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV: return "PhysicalDeviceCornerSampledImageFeaturesNV";
|
|
|
4758 case StructureType::eExternalMemoryImageCreateInfoNV : return "ExternalMemoryImageCreateInfoNV";
|
|
|
4759 case StructureType::eExportMemoryAllocateInfoNV : return "ExportMemoryAllocateInfoNV";
|
|
|
4760 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
4761 case StructureType::eImportMemoryWin32HandleInfoNV : return "ImportMemoryWin32HandleInfoNV";
|
|
|
4762 case StructureType::eExportMemoryWin32HandleInfoNV : return "ExportMemoryWin32HandleInfoNV";
|
|
|
4763 case StructureType::eWin32KeyedMutexAcquireReleaseInfoNV: return "Win32KeyedMutexAcquireReleaseInfoNV";
|
|
|
4764 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
4765 case StructureType::eValidationFlagsEXT: return "ValidationFlagsEXT";
|
|
|
4766 #if defined( VK_USE_PLATFORM_VI_NN )
|
|
|
4767 case StructureType::eViSurfaceCreateInfoNN: return "ViSurfaceCreateInfoNN";
|
|
|
4768 #endif /*VK_USE_PLATFORM_VI_NN*/
|
|
|
4769 case StructureType::eImageViewAstcDecodeModeEXT : return "ImageViewAstcDecodeModeEXT";
|
|
|
4770 case StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT: return "PhysicalDeviceAstcDecodeFeaturesEXT";
|
|
|
4771 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
4772 case StructureType::eImportMemoryWin32HandleInfoKHR: return "ImportMemoryWin32HandleInfoKHR";
|
|
|
4773 case StructureType::eExportMemoryWin32HandleInfoKHR: return "ExportMemoryWin32HandleInfoKHR";
|
|
|
4774 case StructureType::eMemoryWin32HandlePropertiesKHR: return "MemoryWin32HandlePropertiesKHR";
|
|
|
4775 case StructureType::eMemoryGetWin32HandleInfoKHR : return "MemoryGetWin32HandleInfoKHR";
|
|
|
4776 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
4777 case StructureType::eImportMemoryFdInfoKHR: return "ImportMemoryFdInfoKHR";
|
|
|
4778 case StructureType::eMemoryFdPropertiesKHR: return "MemoryFdPropertiesKHR";
|
|
|
4779 case StructureType::eMemoryGetFdInfoKHR : return "MemoryGetFdInfoKHR";
|
|
|
4780 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
4781 case StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR: return "Win32KeyedMutexAcquireReleaseInfoKHR";
|
|
|
4782 case StructureType::eImportSemaphoreWin32HandleInfoKHR : return "ImportSemaphoreWin32HandleInfoKHR";
|
|
|
4783 case StructureType::eExportSemaphoreWin32HandleInfoKHR : return "ExportSemaphoreWin32HandleInfoKHR";
|
|
|
4784 case StructureType::eD3D12FenceSubmitInfoKHR : return "D3D12FenceSubmitInfoKHR";
|
|
|
4785 case StructureType::eSemaphoreGetWin32HandleInfoKHR : return "SemaphoreGetWin32HandleInfoKHR";
|
|
|
4786 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
4787 case StructureType::eImportSemaphoreFdInfoKHR : return "ImportSemaphoreFdInfoKHR";
|
|
|
4788 case StructureType::eSemaphoreGetFdInfoKHR : return "SemaphoreGetFdInfoKHR";
|
|
|
4789 case StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT : return "CommandBufferInheritanceConditionalRenderingInfoEXT";
|
|
|
4790 case StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT : return "PhysicalDeviceConditionalRenderingFeaturesEXT";
|
|
|
4791 case StructureType::eConditionalRenderingBeginInfoEXT : return "ConditionalRenderingBeginInfoEXT";
|
|
|
4792 case StructureType::ePresentRegionsKHR : return "PresentRegionsKHR";
|
|
|
4793 case StructureType::ePipelineViewportWScalingStateCreateInfoNV : return "PipelineViewportWScalingStateCreateInfoNV";
|
|
|
4794 case StructureType::eSurfaceCapabilities2EXT : return "SurfaceCapabilities2EXT";
|
|
|
4795 case StructureType::eDisplayPowerInfoEXT : return "DisplayPowerInfoEXT";
|
|
|
4796 case StructureType::eDeviceEventInfoEXT : return "DeviceEventInfoEXT";
|
|
|
4797 case StructureType::eDisplayEventInfoEXT : return "DisplayEventInfoEXT";
|
|
|
4798 case StructureType::eSwapchainCounterCreateInfoEXT : return "SwapchainCounterCreateInfoEXT";
|
|
|
4799 case StructureType::ePresentTimesInfoGOOGLE : return "PresentTimesInfoGOOGLE";
|
|
|
4800 case StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX: return "PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX";
|
|
|
4801 case StructureType::eMultiviewPerViewAttributesInfoNVX : return "MultiviewPerViewAttributesInfoNVX";
|
|
|
4802 case StructureType::ePipelineViewportSwizzleStateCreateInfoNV : return "PipelineViewportSwizzleStateCreateInfoNV";
|
|
|
4803 case StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT : return "PhysicalDeviceDiscardRectanglePropertiesEXT";
|
|
|
4804 case StructureType::ePipelineDiscardRectangleStateCreateInfoEXT : return "PipelineDiscardRectangleStateCreateInfoEXT";
|
|
|
4805 case StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT : return "PhysicalDeviceConservativeRasterizationPropertiesEXT";
|
|
|
4806 case StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT : return "PipelineRasterizationConservativeStateCreateInfoEXT";
|
|
|
4807 case StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT : return "PhysicalDeviceDepthClipEnableFeaturesEXT";
|
|
|
4808 case StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT : return "PipelineRasterizationDepthClipStateCreateInfoEXT";
|
|
|
4809 case StructureType::eHdrMetadataEXT : return "HdrMetadataEXT";
|
|
|
4810 case StructureType::ePhysicalDeviceRelaxedLineRasterizationFeaturesIMG : return "PhysicalDeviceRelaxedLineRasterizationFeaturesIMG";
|
|
|
4811 case StructureType::eSharedPresentSurfaceCapabilitiesKHR : return "SharedPresentSurfaceCapabilitiesKHR";
|
|
|
4812 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
4813 case StructureType::eImportFenceWin32HandleInfoKHR: return "ImportFenceWin32HandleInfoKHR";
|
|
|
4814 case StructureType::eExportFenceWin32HandleInfoKHR: return "ExportFenceWin32HandleInfoKHR";
|
|
|
4815 case StructureType::eFenceGetWin32HandleInfoKHR : return "FenceGetWin32HandleInfoKHR";
|
|
|
4816 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
4817 case StructureType::eImportFenceFdInfoKHR : return "ImportFenceFdInfoKHR";
|
|
|
4818 case StructureType::eFenceGetFdInfoKHR : return "FenceGetFdInfoKHR";
|
|
|
4819 case StructureType::ePhysicalDevicePerformanceQueryFeaturesKHR : return "PhysicalDevicePerformanceQueryFeaturesKHR";
|
|
|
4820 case StructureType::ePhysicalDevicePerformanceQueryPropertiesKHR: return "PhysicalDevicePerformanceQueryPropertiesKHR";
|
|
|
4821 case StructureType::eQueryPoolPerformanceCreateInfoKHR : return "QueryPoolPerformanceCreateInfoKHR";
|
|
|
4822 case StructureType::ePerformanceQuerySubmitInfoKHR : return "PerformanceQuerySubmitInfoKHR";
|
|
|
4823 case StructureType::eAcquireProfilingLockInfoKHR : return "AcquireProfilingLockInfoKHR";
|
|
|
4824 case StructureType::ePerformanceCounterKHR : return "PerformanceCounterKHR";
|
|
|
4825 case StructureType::ePerformanceCounterDescriptionKHR : return "PerformanceCounterDescriptionKHR";
|
|
|
4826 case StructureType::ePhysicalDeviceSurfaceInfo2KHR : return "PhysicalDeviceSurfaceInfo2KHR";
|
|
|
4827 case StructureType::eSurfaceCapabilities2KHR : return "SurfaceCapabilities2KHR";
|
|
|
4828 case StructureType::eSurfaceFormat2KHR : return "SurfaceFormat2KHR";
|
|
|
4829 case StructureType::eDisplayProperties2KHR : return "DisplayProperties2KHR";
|
|
|
4830 case StructureType::eDisplayPlaneProperties2KHR : return "DisplayPlaneProperties2KHR";
|
|
|
4831 case StructureType::eDisplayModeProperties2KHR : return "DisplayModeProperties2KHR";
|
|
|
4832 case StructureType::eDisplayPlaneInfo2KHR : return "DisplayPlaneInfo2KHR";
|
|
|
4833 case StructureType::eDisplayPlaneCapabilities2KHR : return "DisplayPlaneCapabilities2KHR";
|
|
|
4834 #if defined( VK_USE_PLATFORM_IOS_MVK )
|
|
|
4835 case StructureType::eIosSurfaceCreateInfoMVK: return "IosSurfaceCreateInfoMVK";
|
|
|
4836 #endif /*VK_USE_PLATFORM_IOS_MVK*/
|
|
|
4837 #if defined( VK_USE_PLATFORM_MACOS_MVK )
|
|
|
4838 case StructureType::eMacosSurfaceCreateInfoMVK: return "MacosSurfaceCreateInfoMVK";
|
|
|
4839 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
|
|
|
4840 case StructureType::eDebugUtilsObjectNameInfoEXT : return "DebugUtilsObjectNameInfoEXT";
|
|
|
4841 case StructureType::eDebugUtilsObjectTagInfoEXT : return "DebugUtilsObjectTagInfoEXT";
|
|
|
4842 case StructureType::eDebugUtilsLabelEXT : return "DebugUtilsLabelEXT";
|
|
|
4843 case StructureType::eDebugUtilsMessengerCallbackDataEXT: return "DebugUtilsMessengerCallbackDataEXT";
|
|
|
4844 case StructureType::eDebugUtilsMessengerCreateInfoEXT : return "DebugUtilsMessengerCreateInfoEXT";
|
|
|
4845 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
|
4846 case StructureType::eAndroidHardwareBufferUsageANDROID : return "AndroidHardwareBufferUsageANDROID";
|
|
|
4847 case StructureType::eAndroidHardwareBufferPropertiesANDROID : return "AndroidHardwareBufferPropertiesANDROID";
|
|
|
4848 case StructureType::eAndroidHardwareBufferFormatPropertiesANDROID : return "AndroidHardwareBufferFormatPropertiesANDROID";
|
|
|
4849 case StructureType::eImportAndroidHardwareBufferInfoANDROID : return "ImportAndroidHardwareBufferInfoANDROID";
|
|
|
4850 case StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID : return "MemoryGetAndroidHardwareBufferInfoANDROID";
|
|
|
4851 case StructureType::eExternalFormatANDROID : return "ExternalFormatANDROID";
|
|
|
4852 case StructureType::eAndroidHardwareBufferFormatProperties2ANDROID: return "AndroidHardwareBufferFormatProperties2ANDROID";
|
|
|
4853 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
4854 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
4855 case StructureType::ePhysicalDeviceShaderEnqueueFeaturesAMDX : return "PhysicalDeviceShaderEnqueueFeaturesAMDX";
|
|
|
4856 case StructureType::ePhysicalDeviceShaderEnqueuePropertiesAMDX: return "PhysicalDeviceShaderEnqueuePropertiesAMDX";
|
|
|
4857 case StructureType::eExecutionGraphPipelineScratchSizeAMDX : return "ExecutionGraphPipelineScratchSizeAMDX";
|
|
|
4858 case StructureType::eExecutionGraphPipelineCreateInfoAMDX : return "ExecutionGraphPipelineCreateInfoAMDX";
|
|
|
4859 case StructureType::ePipelineShaderStageNodeCreateInfoAMDX : return "PipelineShaderStageNodeCreateInfoAMDX";
|
|
|
4860 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
4861 case StructureType::eAttachmentSampleCountInfoAMD : return "AttachmentSampleCountInfoAMD";
|
|
|
4862 case StructureType::ePhysicalDeviceShaderBfloat16FeaturesKHR : return "PhysicalDeviceShaderBfloat16FeaturesKHR";
|
|
|
4863 case StructureType::eSampleLocationsInfoEXT : return "SampleLocationsInfoEXT";
|
|
|
4864 case StructureType::eRenderPassSampleLocationsBeginInfoEXT : return "RenderPassSampleLocationsBeginInfoEXT";
|
|
|
4865 case StructureType::ePipelineSampleLocationsStateCreateInfoEXT : return "PipelineSampleLocationsStateCreateInfoEXT";
|
|
|
4866 case StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT : return "PhysicalDeviceSampleLocationsPropertiesEXT";
|
|
|
4867 case StructureType::eMultisamplePropertiesEXT : return "MultisamplePropertiesEXT";
|
|
|
4868 case StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT : return "PhysicalDeviceBlendOperationAdvancedFeaturesEXT";
|
|
|
4869 case StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT: return "PhysicalDeviceBlendOperationAdvancedPropertiesEXT";
|
|
|
4870 case StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT : return "PipelineColorBlendAdvancedStateCreateInfoEXT";
|
|
|
4871 case StructureType::ePipelineCoverageToColorStateCreateInfoNV : return "PipelineCoverageToColorStateCreateInfoNV";
|
|
|
4872 case StructureType::eWriteDescriptorSetAccelerationStructureKHR : return "WriteDescriptorSetAccelerationStructureKHR";
|
|
|
4873 case StructureType::eAccelerationStructureBuildGeometryInfoKHR : return "AccelerationStructureBuildGeometryInfoKHR";
|
|
|
4874 case StructureType::eAccelerationStructureDeviceAddressInfoKHR : return "AccelerationStructureDeviceAddressInfoKHR";
|
|
|
4875 case StructureType::eAccelerationStructureGeometryAabbsDataKHR : return "AccelerationStructureGeometryAabbsDataKHR";
|
|
|
4876 case StructureType::eAccelerationStructureGeometryInstancesDataKHR : return "AccelerationStructureGeometryInstancesDataKHR";
|
|
|
4877 case StructureType::eAccelerationStructureGeometryTrianglesDataKHR : return "AccelerationStructureGeometryTrianglesDataKHR";
|
|
|
4878 case StructureType::eAccelerationStructureGeometryKHR : return "AccelerationStructureGeometryKHR";
|
|
|
4879 case StructureType::eAccelerationStructureVersionInfoKHR : return "AccelerationStructureVersionInfoKHR";
|
|
|
4880 case StructureType::eCopyAccelerationStructureInfoKHR : return "CopyAccelerationStructureInfoKHR";
|
|
|
4881 case StructureType::eCopyAccelerationStructureToMemoryInfoKHR : return "CopyAccelerationStructureToMemoryInfoKHR";
|
|
|
4882 case StructureType::eCopyMemoryToAccelerationStructureInfoKHR : return "CopyMemoryToAccelerationStructureInfoKHR";
|
|
|
4883 case StructureType::ePhysicalDeviceAccelerationStructureFeaturesKHR : return "PhysicalDeviceAccelerationStructureFeaturesKHR";
|
|
|
4884 case StructureType::ePhysicalDeviceAccelerationStructurePropertiesKHR : return "PhysicalDeviceAccelerationStructurePropertiesKHR";
|
|
|
4885 case StructureType::eAccelerationStructureCreateInfoKHR : return "AccelerationStructureCreateInfoKHR";
|
|
|
4886 case StructureType::eAccelerationStructureBuildSizesInfoKHR : return "AccelerationStructureBuildSizesInfoKHR";
|
|
|
4887 case StructureType::ePhysicalDeviceRayTracingPipelineFeaturesKHR : return "PhysicalDeviceRayTracingPipelineFeaturesKHR";
|
|
|
4888 case StructureType::ePhysicalDeviceRayTracingPipelinePropertiesKHR : return "PhysicalDeviceRayTracingPipelinePropertiesKHR";
|
|
|
4889 case StructureType::eRayTracingPipelineCreateInfoKHR : return "RayTracingPipelineCreateInfoKHR";
|
|
|
4890 case StructureType::eRayTracingShaderGroupCreateInfoKHR : return "RayTracingShaderGroupCreateInfoKHR";
|
|
|
4891 case StructureType::eRayTracingPipelineInterfaceCreateInfoKHR : return "RayTracingPipelineInterfaceCreateInfoKHR";
|
|
|
4892 case StructureType::ePhysicalDeviceRayQueryFeaturesKHR : return "PhysicalDeviceRayQueryFeaturesKHR";
|
|
|
4893 case StructureType::ePipelineCoverageModulationStateCreateInfoNV : return "PipelineCoverageModulationStateCreateInfoNV";
|
|
|
4894 case StructureType::ePhysicalDeviceShaderSmBuiltinsFeaturesNV : return "PhysicalDeviceShaderSmBuiltinsFeaturesNV";
|
|
|
4895 case StructureType::ePhysicalDeviceShaderSmBuiltinsPropertiesNV : return "PhysicalDeviceShaderSmBuiltinsPropertiesNV";
|
|
|
4896 case StructureType::eDrmFormatModifierPropertiesListEXT : return "DrmFormatModifierPropertiesListEXT";
|
|
|
4897 case StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT : return "PhysicalDeviceImageDrmFormatModifierInfoEXT";
|
|
|
4898 case StructureType::eImageDrmFormatModifierListCreateInfoEXT : return "ImageDrmFormatModifierListCreateInfoEXT";
|
|
|
4899 case StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT : return "ImageDrmFormatModifierExplicitCreateInfoEXT";
|
|
|
4900 case StructureType::eImageDrmFormatModifierPropertiesEXT : return "ImageDrmFormatModifierPropertiesEXT";
|
|
|
4901 case StructureType::eDrmFormatModifierPropertiesList2EXT : return "DrmFormatModifierPropertiesList2EXT";
|
|
|
4902 case StructureType::eValidationCacheCreateInfoEXT : return "ValidationCacheCreateInfoEXT";
|
|
|
4903 case StructureType::eShaderModuleValidationCacheCreateInfoEXT : return "ShaderModuleValidationCacheCreateInfoEXT";
|
|
|
4904 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
4905 case StructureType::ePhysicalDevicePortabilitySubsetFeaturesKHR : return "PhysicalDevicePortabilitySubsetFeaturesKHR";
|
|
|
4906 case StructureType::ePhysicalDevicePortabilitySubsetPropertiesKHR: return "PhysicalDevicePortabilitySubsetPropertiesKHR";
|
|
|
4907 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
4908 case StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV : return "PipelineViewportShadingRateImageStateCreateInfoNV";
|
|
|
4909 case StructureType::ePhysicalDeviceShadingRateImageFeaturesNV : return "PhysicalDeviceShadingRateImageFeaturesNV";
|
|
|
4910 case StructureType::ePhysicalDeviceShadingRateImagePropertiesNV : return "PhysicalDeviceShadingRateImagePropertiesNV";
|
|
|
4911 case StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV : return "PipelineViewportCoarseSampleOrderStateCreateInfoNV";
|
|
|
4912 case StructureType::eRayTracingPipelineCreateInfoNV : return "RayTracingPipelineCreateInfoNV";
|
|
|
4913 case StructureType::eAccelerationStructureCreateInfoNV : return "AccelerationStructureCreateInfoNV";
|
|
|
4914 case StructureType::eGeometryNV : return "GeometryNV";
|
|
|
4915 case StructureType::eGeometryTrianglesNV : return "GeometryTrianglesNV";
|
|
|
4916 case StructureType::eGeometryAabbNV : return "GeometryAabbNV";
|
|
|
4917 case StructureType::eBindAccelerationStructureMemoryInfoNV : return "BindAccelerationStructureMemoryInfoNV";
|
|
|
4918 case StructureType::eWriteDescriptorSetAccelerationStructureNV : return "WriteDescriptorSetAccelerationStructureNV";
|
|
|
4919 case StructureType::eAccelerationStructureMemoryRequirementsInfoNV : return "AccelerationStructureMemoryRequirementsInfoNV";
|
|
|
4920 case StructureType::ePhysicalDeviceRayTracingPropertiesNV : return "PhysicalDeviceRayTracingPropertiesNV";
|
|
|
4921 case StructureType::eRayTracingShaderGroupCreateInfoNV : return "RayTracingShaderGroupCreateInfoNV";
|
|
|
4922 case StructureType::eAccelerationStructureInfoNV : return "AccelerationStructureInfoNV";
|
|
|
4923 case StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV : return "PhysicalDeviceRepresentativeFragmentTestFeaturesNV";
|
|
|
4924 case StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV: return "PipelineRepresentativeFragmentTestStateCreateInfoNV";
|
|
|
4925 case StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT : return "PhysicalDeviceImageViewImageFormatInfoEXT";
|
|
|
4926 case StructureType::eFilterCubicImageViewImageFormatPropertiesEXT : return "FilterCubicImageViewImageFormatPropertiesEXT";
|
|
|
4927 case StructureType::eImportMemoryHostPointerInfoEXT : return "ImportMemoryHostPointerInfoEXT";
|
|
|
4928 case StructureType::eMemoryHostPointerPropertiesEXT : return "MemoryHostPointerPropertiesEXT";
|
|
|
4929 case StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT : return "PhysicalDeviceExternalMemoryHostPropertiesEXT";
|
|
|
4930 case StructureType::ePhysicalDeviceShaderClockFeaturesKHR : return "PhysicalDeviceShaderClockFeaturesKHR";
|
|
|
4931 case StructureType::ePipelineCompilerControlCreateInfoAMD : return "PipelineCompilerControlCreateInfoAMD";
|
|
|
4932 case StructureType::ePhysicalDeviceShaderCorePropertiesAMD : return "PhysicalDeviceShaderCorePropertiesAMD";
|
|
|
4933 case StructureType::eVideoDecodeH265CapabilitiesKHR : return "VideoDecodeH265CapabilitiesKHR";
|
|
|
4934 case StructureType::eVideoDecodeH265SessionParametersCreateInfoKHR : return "VideoDecodeH265SessionParametersCreateInfoKHR";
|
|
|
4935 case StructureType::eVideoDecodeH265SessionParametersAddInfoKHR : return "VideoDecodeH265SessionParametersAddInfoKHR";
|
|
|
4936 case StructureType::eVideoDecodeH265ProfileInfoKHR : return "VideoDecodeH265ProfileInfoKHR";
|
|
|
4937 case StructureType::eVideoDecodeH265PictureInfoKHR : return "VideoDecodeH265PictureInfoKHR";
|
|
|
4938 case StructureType::eVideoDecodeH265DpbSlotInfoKHR : return "VideoDecodeH265DpbSlotInfoKHR";
|
|
|
4939 case StructureType::eDeviceMemoryOverallocationCreateInfoAMD : return "DeviceMemoryOverallocationCreateInfoAMD";
|
|
|
4940 case StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT : return "PhysicalDeviceVertexAttributeDivisorPropertiesEXT";
|
|
|
4941 #if defined( VK_USE_PLATFORM_GGP )
|
|
|
4942 case StructureType::ePresentFrameTokenGGP: return "PresentFrameTokenGGP";
|
|
|
4943 #endif /*VK_USE_PLATFORM_GGP*/
|
|
|
4944 case StructureType::ePhysicalDeviceMeshShaderFeaturesNV : return "PhysicalDeviceMeshShaderFeaturesNV";
|
|
|
4945 case StructureType::ePhysicalDeviceMeshShaderPropertiesNV : return "PhysicalDeviceMeshShaderPropertiesNV";
|
|
|
4946 case StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV : return "PhysicalDeviceShaderImageFootprintFeaturesNV";
|
|
|
4947 case StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV : return "PipelineViewportExclusiveScissorStateCreateInfoNV";
|
|
|
4948 case StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV : return "PhysicalDeviceExclusiveScissorFeaturesNV";
|
|
|
4949 case StructureType::eCheckpointDataNV : return "CheckpointDataNV";
|
|
|
4950 case StructureType::eQueueFamilyCheckpointPropertiesNV : return "QueueFamilyCheckpointPropertiesNV";
|
|
|
4951 case StructureType::eQueueFamilyCheckpointProperties2NV : return "QueueFamilyCheckpointProperties2NV";
|
|
|
4952 case StructureType::eCheckpointData2NV : return "CheckpointData2NV";
|
|
|
4953 case StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL: return "PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL";
|
|
|
4954 case StructureType::eQueryPoolPerformanceQueryCreateInfoINTEL : return "QueryPoolPerformanceQueryCreateInfoINTEL";
|
|
|
4955 case StructureType::eInitializePerformanceApiInfoINTEL : return "InitializePerformanceApiInfoINTEL";
|
|
|
4956 case StructureType::ePerformanceMarkerInfoINTEL : return "PerformanceMarkerInfoINTEL";
|
|
|
4957 case StructureType::ePerformanceStreamMarkerInfoINTEL : return "PerformanceStreamMarkerInfoINTEL";
|
|
|
4958 case StructureType::ePerformanceOverrideInfoINTEL : return "PerformanceOverrideInfoINTEL";
|
|
|
4959 case StructureType::ePerformanceConfigurationAcquireInfoINTEL : return "PerformanceConfigurationAcquireInfoINTEL";
|
|
|
4960 case StructureType::ePhysicalDevicePciBusInfoPropertiesEXT : return "PhysicalDevicePciBusInfoPropertiesEXT";
|
|
|
4961 case StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD : return "DisplayNativeHdrSurfaceCapabilitiesAMD";
|
|
|
4962 case StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD : return "SwapchainDisplayNativeHdrCreateInfoAMD";
|
|
|
4963 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
4964 case StructureType::eImagepipeSurfaceCreateInfoFUCHSIA: return "ImagepipeSurfaceCreateInfoFUCHSIA";
|
|
|
4965 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
4966 #if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
4967 case StructureType::eMetalSurfaceCreateInfoEXT: return "MetalSurfaceCreateInfoEXT";
|
|
|
4968 #endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
4969 case StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT : return "PhysicalDeviceFragmentDensityMapFeaturesEXT";
|
|
|
4970 case StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT : return "PhysicalDeviceFragmentDensityMapPropertiesEXT";
|
|
|
4971 case StructureType::eRenderPassFragmentDensityMapCreateInfoEXT : return "RenderPassFragmentDensityMapCreateInfoEXT";
|
|
|
4972 case StructureType::eRenderingFragmentDensityMapAttachmentInfoEXT : return "RenderingFragmentDensityMapAttachmentInfoEXT";
|
|
|
4973 case StructureType::eFragmentShadingRateAttachmentInfoKHR : return "FragmentShadingRateAttachmentInfoKHR";
|
|
|
4974 case StructureType::ePipelineFragmentShadingRateStateCreateInfoKHR : return "PipelineFragmentShadingRateStateCreateInfoKHR";
|
|
|
4975 case StructureType::ePhysicalDeviceFragmentShadingRatePropertiesKHR : return "PhysicalDeviceFragmentShadingRatePropertiesKHR";
|
|
|
4976 case StructureType::ePhysicalDeviceFragmentShadingRateFeaturesKHR : return "PhysicalDeviceFragmentShadingRateFeaturesKHR";
|
|
|
4977 case StructureType::ePhysicalDeviceFragmentShadingRateKHR : return "PhysicalDeviceFragmentShadingRateKHR";
|
|
|
4978 case StructureType::eRenderingFragmentShadingRateAttachmentInfoKHR : return "RenderingFragmentShadingRateAttachmentInfoKHR";
|
|
|
4979 case StructureType::ePhysicalDeviceShaderCoreProperties2AMD : return "PhysicalDeviceShaderCoreProperties2AMD";
|
|
|
4980 case StructureType::ePhysicalDeviceCoherentMemoryFeaturesAMD : return "PhysicalDeviceCoherentMemoryFeaturesAMD";
|
|
|
4981 case StructureType::ePhysicalDeviceShaderImageAtomicInt64FeaturesEXT : return "PhysicalDeviceShaderImageAtomicInt64FeaturesEXT";
|
|
|
4982 case StructureType::ePhysicalDeviceShaderQuadControlFeaturesKHR : return "PhysicalDeviceShaderQuadControlFeaturesKHR";
|
|
|
4983 case StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT : return "PhysicalDeviceMemoryBudgetPropertiesEXT";
|
|
|
4984 case StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT : return "PhysicalDeviceMemoryPriorityFeaturesEXT";
|
|
|
4985 case StructureType::eMemoryPriorityAllocateInfoEXT : return "MemoryPriorityAllocateInfoEXT";
|
|
|
4986 case StructureType::eSurfaceProtectedCapabilitiesKHR : return "SurfaceProtectedCapabilitiesKHR";
|
|
|
4987 case StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV: return "PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV";
|
|
|
4988 case StructureType::ePhysicalDeviceBufferDeviceAddressFeaturesEXT : return "PhysicalDeviceBufferDeviceAddressFeaturesEXT";
|
|
|
4989 case StructureType::eBufferDeviceAddressCreateInfoEXT : return "BufferDeviceAddressCreateInfoEXT";
|
|
|
4990 case StructureType::eValidationFeaturesEXT : return "ValidationFeaturesEXT";
|
|
|
4991 case StructureType::ePhysicalDevicePresentWaitFeaturesKHR : return "PhysicalDevicePresentWaitFeaturesKHR";
|
|
|
4992 case StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV : return "PhysicalDeviceCooperativeMatrixFeaturesNV";
|
|
|
4993 case StructureType::eCooperativeMatrixPropertiesNV : return "CooperativeMatrixPropertiesNV";
|
|
|
4994 case StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV : return "PhysicalDeviceCooperativeMatrixPropertiesNV";
|
|
|
4995 case StructureType::ePhysicalDeviceCoverageReductionModeFeaturesNV : return "PhysicalDeviceCoverageReductionModeFeaturesNV";
|
|
|
4996 case StructureType::ePipelineCoverageReductionStateCreateInfoNV : return "PipelineCoverageReductionStateCreateInfoNV";
|
|
|
4997 case StructureType::eFramebufferMixedSamplesCombinationNV : return "FramebufferMixedSamplesCombinationNV";
|
|
|
4998 case StructureType::ePhysicalDeviceFragmentShaderInterlockFeaturesEXT : return "PhysicalDeviceFragmentShaderInterlockFeaturesEXT";
|
|
|
4999 case StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT : return "PhysicalDeviceYcbcrImageArraysFeaturesEXT";
|
|
|
5000 case StructureType::ePhysicalDeviceProvokingVertexFeaturesEXT : return "PhysicalDeviceProvokingVertexFeaturesEXT";
|
|
|
5001 case StructureType::ePipelineRasterizationProvokingVertexStateCreateInfoEXT : return "PipelineRasterizationProvokingVertexStateCreateInfoEXT";
|
|
|
5002 case StructureType::ePhysicalDeviceProvokingVertexPropertiesEXT : return "PhysicalDeviceProvokingVertexPropertiesEXT";
|
|
|
5003 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
5004 case StructureType::eSurfaceFullScreenExclusiveInfoEXT : return "SurfaceFullScreenExclusiveInfoEXT";
|
|
|
5005 case StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT: return "SurfaceCapabilitiesFullScreenExclusiveEXT";
|
|
|
5006 case StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT : return "SurfaceFullScreenExclusiveWin32InfoEXT";
|
|
|
5007 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
5008 case StructureType::eHeadlessSurfaceCreateInfoEXT : return "HeadlessSurfaceCreateInfoEXT";
|
|
|
5009 case StructureType::ePhysicalDeviceShaderAtomicFloatFeaturesEXT : return "PhysicalDeviceShaderAtomicFloatFeaturesEXT";
|
|
|
5010 case StructureType::ePhysicalDeviceExtendedDynamicStateFeaturesEXT : return "PhysicalDeviceExtendedDynamicStateFeaturesEXT";
|
|
|
5011 case StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR: return "PhysicalDevicePipelineExecutablePropertiesFeaturesKHR";
|
|
|
5012 case StructureType::ePipelineInfoKHR : return "PipelineInfoKHR";
|
|
|
5013 case StructureType::ePipelineExecutablePropertiesKHR : return "PipelineExecutablePropertiesKHR";
|
|
|
5014 case StructureType::ePipelineExecutableInfoKHR : return "PipelineExecutableInfoKHR";
|
|
|
5015 case StructureType::ePipelineExecutableStatisticKHR : return "PipelineExecutableStatisticKHR";
|
|
|
5016 case StructureType::ePipelineExecutableInternalRepresentationKHR : return "PipelineExecutableInternalRepresentationKHR";
|
|
|
5017 case StructureType::ePhysicalDeviceMapMemoryPlacedFeaturesEXT : return "PhysicalDeviceMapMemoryPlacedFeaturesEXT";
|
|
|
5018 case StructureType::ePhysicalDeviceMapMemoryPlacedPropertiesEXT : return "PhysicalDeviceMapMemoryPlacedPropertiesEXT";
|
|
|
5019 case StructureType::eMemoryMapPlacedInfoEXT : return "MemoryMapPlacedInfoEXT";
|
|
|
5020 case StructureType::ePhysicalDeviceShaderAtomicFloat2FeaturesEXT : return "PhysicalDeviceShaderAtomicFloat2FeaturesEXT";
|
|
|
5021 case StructureType::ePhysicalDeviceDeviceGeneratedCommandsPropertiesNV : return "PhysicalDeviceDeviceGeneratedCommandsPropertiesNV";
|
|
|
5022 case StructureType::eGraphicsShaderGroupCreateInfoNV : return "GraphicsShaderGroupCreateInfoNV";
|
|
|
5023 case StructureType::eGraphicsPipelineShaderGroupsCreateInfoNV : return "GraphicsPipelineShaderGroupsCreateInfoNV";
|
|
|
5024 case StructureType::eIndirectCommandsLayoutTokenNV : return "IndirectCommandsLayoutTokenNV";
|
|
|
5025 case StructureType::eIndirectCommandsLayoutCreateInfoNV : return "IndirectCommandsLayoutCreateInfoNV";
|
|
|
5026 case StructureType::eGeneratedCommandsInfoNV : return "GeneratedCommandsInfoNV";
|
|
|
5027 case StructureType::eGeneratedCommandsMemoryRequirementsInfoNV : return "GeneratedCommandsMemoryRequirementsInfoNV";
|
|
|
5028 case StructureType::ePhysicalDeviceDeviceGeneratedCommandsFeaturesNV : return "PhysicalDeviceDeviceGeneratedCommandsFeaturesNV";
|
|
|
5029 case StructureType::ePhysicalDeviceInheritedViewportScissorFeaturesNV : return "PhysicalDeviceInheritedViewportScissorFeaturesNV";
|
|
|
5030 case StructureType::eCommandBufferInheritanceViewportScissorInfoNV : return "CommandBufferInheritanceViewportScissorInfoNV";
|
|
|
5031 case StructureType::ePhysicalDeviceTexelBufferAlignmentFeaturesEXT : return "PhysicalDeviceTexelBufferAlignmentFeaturesEXT";
|
|
|
5032 case StructureType::eCommandBufferInheritanceRenderPassTransformInfoQCOM : return "CommandBufferInheritanceRenderPassTransformInfoQCOM";
|
|
|
5033 case StructureType::eRenderPassTransformBeginInfoQCOM : return "RenderPassTransformBeginInfoQCOM";
|
|
|
5034 case StructureType::ePhysicalDeviceDepthBiasControlFeaturesEXT : return "PhysicalDeviceDepthBiasControlFeaturesEXT";
|
|
|
5035 case StructureType::eDepthBiasInfoEXT : return "DepthBiasInfoEXT";
|
|
|
5036 case StructureType::eDepthBiasRepresentationInfoEXT : return "DepthBiasRepresentationInfoEXT";
|
|
|
5037 case StructureType::ePhysicalDeviceDeviceMemoryReportFeaturesEXT : return "PhysicalDeviceDeviceMemoryReportFeaturesEXT";
|
|
|
5038 case StructureType::eDeviceDeviceMemoryReportCreateInfoEXT : return "DeviceDeviceMemoryReportCreateInfoEXT";
|
|
|
5039 case StructureType::eDeviceMemoryReportCallbackDataEXT : return "DeviceMemoryReportCallbackDataEXT";
|
|
|
5040 case StructureType::eSamplerCustomBorderColorCreateInfoEXT : return "SamplerCustomBorderColorCreateInfoEXT";
|
|
|
5041 case StructureType::ePhysicalDeviceCustomBorderColorPropertiesEXT : return "PhysicalDeviceCustomBorderColorPropertiesEXT";
|
|
|
5042 case StructureType::ePhysicalDeviceCustomBorderColorFeaturesEXT : return "PhysicalDeviceCustomBorderColorFeaturesEXT";
|
|
|
5043 case StructureType::ePipelineLibraryCreateInfoKHR : return "PipelineLibraryCreateInfoKHR";
|
|
|
5044 case StructureType::ePhysicalDevicePresentBarrierFeaturesNV : return "PhysicalDevicePresentBarrierFeaturesNV";
|
|
|
5045 case StructureType::eSurfaceCapabilitiesPresentBarrierNV : return "SurfaceCapabilitiesPresentBarrierNV";
|
|
|
5046 case StructureType::eSwapchainPresentBarrierCreateInfoNV : return "SwapchainPresentBarrierCreateInfoNV";
|
|
|
5047 case StructureType::ePresentIdKHR : return "PresentIdKHR";
|
|
|
5048 case StructureType::ePhysicalDevicePresentIdFeaturesKHR : return "PhysicalDevicePresentIdFeaturesKHR";
|
|
|
5049 case StructureType::eVideoEncodeInfoKHR : return "VideoEncodeInfoKHR";
|
|
|
5050 case StructureType::eVideoEncodeRateControlInfoKHR : return "VideoEncodeRateControlInfoKHR";
|
|
|
5051 case StructureType::eVideoEncodeRateControlLayerInfoKHR : return "VideoEncodeRateControlLayerInfoKHR";
|
|
|
5052 case StructureType::eVideoEncodeCapabilitiesKHR : return "VideoEncodeCapabilitiesKHR";
|
|
|
5053 case StructureType::eVideoEncodeUsageInfoKHR : return "VideoEncodeUsageInfoKHR";
|
|
|
5054 case StructureType::eQueryPoolVideoEncodeFeedbackCreateInfoKHR : return "QueryPoolVideoEncodeFeedbackCreateInfoKHR";
|
|
|
5055 case StructureType::ePhysicalDeviceVideoEncodeQualityLevelInfoKHR : return "PhysicalDeviceVideoEncodeQualityLevelInfoKHR";
|
|
|
5056 case StructureType::eVideoEncodeQualityLevelPropertiesKHR : return "VideoEncodeQualityLevelPropertiesKHR";
|
|
|
5057 case StructureType::eVideoEncodeQualityLevelInfoKHR : return "VideoEncodeQualityLevelInfoKHR";
|
|
|
5058 case StructureType::eVideoEncodeSessionParametersGetInfoKHR : return "VideoEncodeSessionParametersGetInfoKHR";
|
|
|
5059 case StructureType::eVideoEncodeSessionParametersFeedbackInfoKHR : return "VideoEncodeSessionParametersFeedbackInfoKHR";
|
|
|
5060 case StructureType::ePhysicalDeviceDiagnosticsConfigFeaturesNV : return "PhysicalDeviceDiagnosticsConfigFeaturesNV";
|
|
|
5061 case StructureType::eDeviceDiagnosticsConfigCreateInfoNV : return "DeviceDiagnosticsConfigCreateInfoNV";
|
|
|
5062 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
5063 case StructureType::eCudaModuleCreateInfoNV : return "CudaModuleCreateInfoNV";
|
|
|
5064 case StructureType::eCudaFunctionCreateInfoNV : return "CudaFunctionCreateInfoNV";
|
|
|
5065 case StructureType::eCudaLaunchInfoNV : return "CudaLaunchInfoNV";
|
|
|
5066 case StructureType::ePhysicalDeviceCudaKernelLaunchFeaturesNV : return "PhysicalDeviceCudaKernelLaunchFeaturesNV";
|
|
|
5067 case StructureType::ePhysicalDeviceCudaKernelLaunchPropertiesNV: return "PhysicalDeviceCudaKernelLaunchPropertiesNV";
|
|
|
5068 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
5069 case StructureType::ePhysicalDeviceTileShadingFeaturesQCOM : return "PhysicalDeviceTileShadingFeaturesQCOM";
|
|
|
5070 case StructureType::ePhysicalDeviceTileShadingPropertiesQCOM: return "PhysicalDeviceTileShadingPropertiesQCOM";
|
|
|
5071 case StructureType::eRenderPassTileShadingCreateInfoQCOM : return "RenderPassTileShadingCreateInfoQCOM";
|
|
|
5072 case StructureType::ePerTileBeginInfoQCOM : return "PerTileBeginInfoQCOM";
|
|
|
5073 case StructureType::ePerTileEndInfoQCOM : return "PerTileEndInfoQCOM";
|
|
|
5074 case StructureType::eDispatchTileInfoQCOM : return "DispatchTileInfoQCOM";
|
|
|
5075 case StructureType::eQueryLowLatencySupportNV : return "QueryLowLatencySupportNV";
|
|
|
5076 #if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
5077 case StructureType::eExportMetalObjectCreateInfoEXT: return "ExportMetalObjectCreateInfoEXT";
|
|
|
5078 case StructureType::eExportMetalObjectsInfoEXT : return "ExportMetalObjectsInfoEXT";
|
|
|
5079 case StructureType::eExportMetalDeviceInfoEXT : return "ExportMetalDeviceInfoEXT";
|
|
|
5080 case StructureType::eExportMetalCommandQueueInfoEXT: return "ExportMetalCommandQueueInfoEXT";
|
|
|
5081 case StructureType::eExportMetalBufferInfoEXT : return "ExportMetalBufferInfoEXT";
|
|
|
5082 case StructureType::eImportMetalBufferInfoEXT : return "ImportMetalBufferInfoEXT";
|
|
|
5083 case StructureType::eExportMetalTextureInfoEXT : return "ExportMetalTextureInfoEXT";
|
|
|
5084 case StructureType::eImportMetalTextureInfoEXT : return "ImportMetalTextureInfoEXT";
|
|
|
5085 case StructureType::eExportMetalIoSurfaceInfoEXT : return "ExportMetalIoSurfaceInfoEXT";
|
|
|
5086 case StructureType::eImportMetalIoSurfaceInfoEXT : return "ImportMetalIoSurfaceInfoEXT";
|
|
|
5087 case StructureType::eExportMetalSharedEventInfoEXT : return "ExportMetalSharedEventInfoEXT";
|
|
|
5088 case StructureType::eImportMetalSharedEventInfoEXT : return "ImportMetalSharedEventInfoEXT";
|
|
|
5089 #endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
5090 case StructureType::ePhysicalDeviceDescriptorBufferPropertiesEXT : return "PhysicalDeviceDescriptorBufferPropertiesEXT";
|
|
|
5091 case StructureType::ePhysicalDeviceDescriptorBufferDensityMapPropertiesEXT : return "PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT";
|
|
|
5092 case StructureType::ePhysicalDeviceDescriptorBufferFeaturesEXT : return "PhysicalDeviceDescriptorBufferFeaturesEXT";
|
|
|
5093 case StructureType::eDescriptorAddressInfoEXT : return "DescriptorAddressInfoEXT";
|
|
|
5094 case StructureType::eDescriptorGetInfoEXT : return "DescriptorGetInfoEXT";
|
|
|
5095 case StructureType::eBufferCaptureDescriptorDataInfoEXT : return "BufferCaptureDescriptorDataInfoEXT";
|
|
|
5096 case StructureType::eImageCaptureDescriptorDataInfoEXT : return "ImageCaptureDescriptorDataInfoEXT";
|
|
|
5097 case StructureType::eImageViewCaptureDescriptorDataInfoEXT : return "ImageViewCaptureDescriptorDataInfoEXT";
|
|
|
5098 case StructureType::eSamplerCaptureDescriptorDataInfoEXT : return "SamplerCaptureDescriptorDataInfoEXT";
|
|
|
5099 case StructureType::eOpaqueCaptureDescriptorDataCreateInfoEXT : return "OpaqueCaptureDescriptorDataCreateInfoEXT";
|
|
|
5100 case StructureType::eDescriptorBufferBindingInfoEXT : return "DescriptorBufferBindingInfoEXT";
|
|
|
5101 case StructureType::eDescriptorBufferBindingPushDescriptorBufferHandleEXT : return "DescriptorBufferBindingPushDescriptorBufferHandleEXT";
|
|
|
5102 case StructureType::eAccelerationStructureCaptureDescriptorDataInfoEXT : return "AccelerationStructureCaptureDescriptorDataInfoEXT";
|
|
|
5103 case StructureType::ePhysicalDeviceGraphicsPipelineLibraryFeaturesEXT : return "PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT";
|
|
|
5104 case StructureType::ePhysicalDeviceGraphicsPipelineLibraryPropertiesEXT : return "PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT";
|
|
|
5105 case StructureType::eGraphicsPipelineLibraryCreateInfoEXT : return "GraphicsPipelineLibraryCreateInfoEXT";
|
|
|
5106 case StructureType::ePhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD : return "PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD";
|
|
|
5107 case StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesKHR : return "PhysicalDeviceFragmentShaderBarycentricFeaturesKHR";
|
|
|
5108 case StructureType::ePhysicalDeviceFragmentShaderBarycentricPropertiesKHR : return "PhysicalDeviceFragmentShaderBarycentricPropertiesKHR";
|
|
|
5109 case StructureType::ePhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR: return "PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR";
|
|
|
5110 case StructureType::ePhysicalDeviceFragmentShadingRateEnumsPropertiesNV : return "PhysicalDeviceFragmentShadingRateEnumsPropertiesNV";
|
|
|
5111 case StructureType::ePhysicalDeviceFragmentShadingRateEnumsFeaturesNV : return "PhysicalDeviceFragmentShadingRateEnumsFeaturesNV";
|
|
|
5112 case StructureType::ePipelineFragmentShadingRateEnumStateCreateInfoNV : return "PipelineFragmentShadingRateEnumStateCreateInfoNV";
|
|
|
5113 case StructureType::eAccelerationStructureGeometryMotionTrianglesDataNV : return "AccelerationStructureGeometryMotionTrianglesDataNV";
|
|
|
5114 case StructureType::ePhysicalDeviceRayTracingMotionBlurFeaturesNV : return "PhysicalDeviceRayTracingMotionBlurFeaturesNV";
|
|
|
5115 case StructureType::eAccelerationStructureMotionInfoNV : return "AccelerationStructureMotionInfoNV";
|
|
|
5116 case StructureType::ePhysicalDeviceMeshShaderFeaturesEXT : return "PhysicalDeviceMeshShaderFeaturesEXT";
|
|
|
5117 case StructureType::ePhysicalDeviceMeshShaderPropertiesEXT : return "PhysicalDeviceMeshShaderPropertiesEXT";
|
|
|
5118 case StructureType::ePhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT : return "PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT";
|
|
|
5119 case StructureType::ePhysicalDeviceFragmentDensityMap2FeaturesEXT : return "PhysicalDeviceFragmentDensityMap2FeaturesEXT";
|
|
|
5120 case StructureType::ePhysicalDeviceFragmentDensityMap2PropertiesEXT : return "PhysicalDeviceFragmentDensityMap2PropertiesEXT";
|
|
|
5121 case StructureType::eCopyCommandTransformInfoQCOM : return "CopyCommandTransformInfoQCOM";
|
|
|
5122 case StructureType::ePhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR : return "PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR";
|
|
|
5123 case StructureType::ePhysicalDeviceImageCompressionControlFeaturesEXT : return "PhysicalDeviceImageCompressionControlFeaturesEXT";
|
|
|
5124 case StructureType::eImageCompressionControlEXT : return "ImageCompressionControlEXT";
|
|
|
5125 case StructureType::eImageCompressionPropertiesEXT : return "ImageCompressionPropertiesEXT";
|
|
|
5126 case StructureType::ePhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT : return "PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT";
|
|
|
5127 case StructureType::ePhysicalDevice4444FormatsFeaturesEXT : return "PhysicalDevice4444FormatsFeaturesEXT";
|
|
|
5128 case StructureType::ePhysicalDeviceFaultFeaturesEXT : return "PhysicalDeviceFaultFeaturesEXT";
|
|
|
5129 case StructureType::eDeviceFaultCountsEXT : return "DeviceFaultCountsEXT";
|
|
|
5130 case StructureType::eDeviceFaultInfoEXT : return "DeviceFaultInfoEXT";
|
|
|
5131 case StructureType::ePhysicalDeviceRgba10X6FormatsFeaturesEXT : return "PhysicalDeviceRgba10X6FormatsFeaturesEXT";
|
|
|
5132 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
|
|
|
5133 case StructureType::eDirectfbSurfaceCreateInfoEXT: return "DirectfbSurfaceCreateInfoEXT";
|
|
|
5134 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
|
|
|
5135 case StructureType::ePhysicalDeviceVertexInputDynamicStateFeaturesEXT : return "PhysicalDeviceVertexInputDynamicStateFeaturesEXT";
|
|
|
5136 case StructureType::eVertexInputBindingDescription2EXT : return "VertexInputBindingDescription2EXT";
|
|
|
5137 case StructureType::eVertexInputAttributeDescription2EXT : return "VertexInputAttributeDescription2EXT";
|
|
|
5138 case StructureType::ePhysicalDeviceDrmPropertiesEXT : return "PhysicalDeviceDrmPropertiesEXT";
|
|
|
5139 case StructureType::ePhysicalDeviceAddressBindingReportFeaturesEXT : return "PhysicalDeviceAddressBindingReportFeaturesEXT";
|
|
|
5140 case StructureType::eDeviceAddressBindingCallbackDataEXT : return "DeviceAddressBindingCallbackDataEXT";
|
|
|
5141 case StructureType::ePhysicalDeviceDepthClipControlFeaturesEXT : return "PhysicalDeviceDepthClipControlFeaturesEXT";
|
|
|
5142 case StructureType::ePipelineViewportDepthClipControlCreateInfoEXT : return "PipelineViewportDepthClipControlCreateInfoEXT";
|
|
|
5143 case StructureType::ePhysicalDevicePrimitiveTopologyListRestartFeaturesEXT: return "PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT";
|
|
|
5144 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
5145 case StructureType::eImportMemoryZirconHandleInfoFUCHSIA : return "ImportMemoryZirconHandleInfoFUCHSIA";
|
|
|
5146 case StructureType::eMemoryZirconHandlePropertiesFUCHSIA : return "MemoryZirconHandlePropertiesFUCHSIA";
|
|
|
5147 case StructureType::eMemoryGetZirconHandleInfoFUCHSIA : return "MemoryGetZirconHandleInfoFUCHSIA";
|
|
|
5148 case StructureType::eImportSemaphoreZirconHandleInfoFUCHSIA : return "ImportSemaphoreZirconHandleInfoFUCHSIA";
|
|
|
5149 case StructureType::eSemaphoreGetZirconHandleInfoFUCHSIA : return "SemaphoreGetZirconHandleInfoFUCHSIA";
|
|
|
5150 case StructureType::eBufferCollectionCreateInfoFUCHSIA : return "BufferCollectionCreateInfoFUCHSIA";
|
|
|
5151 case StructureType::eImportMemoryBufferCollectionFUCHSIA : return "ImportMemoryBufferCollectionFUCHSIA";
|
|
|
5152 case StructureType::eBufferCollectionImageCreateInfoFUCHSIA : return "BufferCollectionImageCreateInfoFUCHSIA";
|
|
|
5153 case StructureType::eBufferCollectionPropertiesFUCHSIA : return "BufferCollectionPropertiesFUCHSIA";
|
|
|
5154 case StructureType::eBufferConstraintsInfoFUCHSIA : return "BufferConstraintsInfoFUCHSIA";
|
|
|
5155 case StructureType::eBufferCollectionBufferCreateInfoFUCHSIA: return "BufferCollectionBufferCreateInfoFUCHSIA";
|
|
|
5156 case StructureType::eImageConstraintsInfoFUCHSIA : return "ImageConstraintsInfoFUCHSIA";
|
|
|
5157 case StructureType::eImageFormatConstraintsInfoFUCHSIA : return "ImageFormatConstraintsInfoFUCHSIA";
|
|
|
5158 case StructureType::eSysmemColorSpaceFUCHSIA : return "SysmemColorSpaceFUCHSIA";
|
|
|
5159 case StructureType::eBufferCollectionConstraintsInfoFUCHSIA : return "BufferCollectionConstraintsInfoFUCHSIA";
|
|
|
5160 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
5161 case StructureType::eSubpassShadingPipelineCreateInfoHUAWEI : return "SubpassShadingPipelineCreateInfoHUAWEI";
|
|
|
5162 case StructureType::ePhysicalDeviceSubpassShadingFeaturesHUAWEI : return "PhysicalDeviceSubpassShadingFeaturesHUAWEI";
|
|
|
5163 case StructureType::ePhysicalDeviceSubpassShadingPropertiesHUAWEI : return "PhysicalDeviceSubpassShadingPropertiesHUAWEI";
|
|
|
5164 case StructureType::ePhysicalDeviceInvocationMaskFeaturesHUAWEI : return "PhysicalDeviceInvocationMaskFeaturesHUAWEI";
|
|
|
5165 case StructureType::eMemoryGetRemoteAddressInfoNV : return "MemoryGetRemoteAddressInfoNV";
|
|
|
5166 case StructureType::ePhysicalDeviceExternalMemoryRdmaFeaturesNV : return "PhysicalDeviceExternalMemoryRdmaFeaturesNV";
|
|
|
5167 case StructureType::ePipelinePropertiesIdentifierEXT : return "PipelinePropertiesIdentifierEXT";
|
|
|
5168 case StructureType::ePhysicalDevicePipelinePropertiesFeaturesEXT : return "PhysicalDevicePipelinePropertiesFeaturesEXT";
|
|
|
5169 case StructureType::ePhysicalDeviceFrameBoundaryFeaturesEXT : return "PhysicalDeviceFrameBoundaryFeaturesEXT";
|
|
|
5170 case StructureType::eFrameBoundaryEXT : return "FrameBoundaryEXT";
|
|
|
5171 case StructureType::ePhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT: return "PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT";
|
|
|
5172 case StructureType::eSubpassResolvePerformanceQueryEXT : return "SubpassResolvePerformanceQueryEXT";
|
|
|
5173 case StructureType::eMultisampledRenderToSingleSampledInfoEXT : return "MultisampledRenderToSingleSampledInfoEXT";
|
|
|
5174 case StructureType::ePhysicalDeviceExtendedDynamicState2FeaturesEXT : return "PhysicalDeviceExtendedDynamicState2FeaturesEXT";
|
|
|
5175 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
|
5176 case StructureType::eScreenSurfaceCreateInfoQNX: return "ScreenSurfaceCreateInfoQNX";
|
|
|
5177 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
|
5178 case StructureType::ePhysicalDeviceColorWriteEnableFeaturesEXT : return "PhysicalDeviceColorWriteEnableFeaturesEXT";
|
|
|
5179 case StructureType::ePipelineColorWriteCreateInfoEXT : return "PipelineColorWriteCreateInfoEXT";
|
|
|
5180 case StructureType::ePhysicalDevicePrimitivesGeneratedQueryFeaturesEXT : return "PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT";
|
|
|
5181 case StructureType::ePhysicalDeviceRayTracingMaintenance1FeaturesKHR : return "PhysicalDeviceRayTracingMaintenance1FeaturesKHR";
|
|
|
5182 case StructureType::ePhysicalDeviceShaderUntypedPointersFeaturesKHR : return "PhysicalDeviceShaderUntypedPointersFeaturesKHR";
|
|
|
5183 case StructureType::ePhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE: return "PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE";
|
|
|
5184 case StructureType::eVideoEncodeRgbConversionCapabilitiesVALVE : return "VideoEncodeRgbConversionCapabilitiesVALVE";
|
|
|
5185 case StructureType::eVideoEncodeProfileRgbConversionInfoVALVE : return "VideoEncodeProfileRgbConversionInfoVALVE";
|
|
|
5186 case StructureType::eVideoEncodeSessionRgbConversionCreateInfoVALVE : return "VideoEncodeSessionRgbConversionCreateInfoVALVE";
|
|
|
5187 case StructureType::ePhysicalDeviceImageViewMinLodFeaturesEXT : return "PhysicalDeviceImageViewMinLodFeaturesEXT";
|
|
|
5188 case StructureType::eImageViewMinLodCreateInfoEXT : return "ImageViewMinLodCreateInfoEXT";
|
|
|
5189 case StructureType::ePhysicalDeviceMultiDrawFeaturesEXT : return "PhysicalDeviceMultiDrawFeaturesEXT";
|
|
|
5190 case StructureType::ePhysicalDeviceMultiDrawPropertiesEXT : return "PhysicalDeviceMultiDrawPropertiesEXT";
|
|
|
5191 case StructureType::ePhysicalDeviceImage2DViewOf3DFeaturesEXT : return "PhysicalDeviceImage2DViewOf3DFeaturesEXT";
|
|
|
5192 case StructureType::ePhysicalDeviceShaderTileImageFeaturesEXT : return "PhysicalDeviceShaderTileImageFeaturesEXT";
|
|
|
5193 case StructureType::ePhysicalDeviceShaderTileImagePropertiesEXT : return "PhysicalDeviceShaderTileImagePropertiesEXT";
|
|
|
5194 case StructureType::eMicromapBuildInfoEXT : return "MicromapBuildInfoEXT";
|
|
|
5195 case StructureType::eMicromapVersionInfoEXT : return "MicromapVersionInfoEXT";
|
|
|
5196 case StructureType::eCopyMicromapInfoEXT : return "CopyMicromapInfoEXT";
|
|
|
5197 case StructureType::eCopyMicromapToMemoryInfoEXT : return "CopyMicromapToMemoryInfoEXT";
|
|
|
5198 case StructureType::eCopyMemoryToMicromapInfoEXT : return "CopyMemoryToMicromapInfoEXT";
|
|
|
5199 case StructureType::ePhysicalDeviceOpacityMicromapFeaturesEXT : return "PhysicalDeviceOpacityMicromapFeaturesEXT";
|
|
|
5200 case StructureType::ePhysicalDeviceOpacityMicromapPropertiesEXT : return "PhysicalDeviceOpacityMicromapPropertiesEXT";
|
|
|
5201 case StructureType::eMicromapCreateInfoEXT : return "MicromapCreateInfoEXT";
|
|
|
5202 case StructureType::eMicromapBuildSizesInfoEXT : return "MicromapBuildSizesInfoEXT";
|
|
|
5203 case StructureType::eAccelerationStructureTrianglesOpacityMicromapEXT : return "AccelerationStructureTrianglesOpacityMicromapEXT";
|
|
|
5204 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
5205 case StructureType::ePhysicalDeviceDisplacementMicromapFeaturesNV : return "PhysicalDeviceDisplacementMicromapFeaturesNV";
|
|
|
5206 case StructureType::ePhysicalDeviceDisplacementMicromapPropertiesNV : return "PhysicalDeviceDisplacementMicromapPropertiesNV";
|
|
|
5207 case StructureType::eAccelerationStructureTrianglesDisplacementMicromapNV: return "AccelerationStructureTrianglesDisplacementMicromapNV";
|
|
|
5208 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
5209 case StructureType::ePhysicalDeviceClusterCullingShaderFeaturesHUAWEI : return "PhysicalDeviceClusterCullingShaderFeaturesHUAWEI";
|
|
|
5210 case StructureType::ePhysicalDeviceClusterCullingShaderPropertiesHUAWEI : return "PhysicalDeviceClusterCullingShaderPropertiesHUAWEI";
|
|
|
5211 case StructureType::ePhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI : return "PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI";
|
|
|
5212 case StructureType::ePhysicalDeviceBorderColorSwizzleFeaturesEXT : return "PhysicalDeviceBorderColorSwizzleFeaturesEXT";
|
|
|
5213 case StructureType::eSamplerBorderColorComponentMappingCreateInfoEXT : return "SamplerBorderColorComponentMappingCreateInfoEXT";
|
|
|
5214 case StructureType::ePhysicalDevicePageableDeviceLocalMemoryFeaturesEXT : return "PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT";
|
|
|
5215 case StructureType::ePhysicalDeviceShaderCorePropertiesARM : return "PhysicalDeviceShaderCorePropertiesARM";
|
|
|
5216 case StructureType::eDeviceQueueShaderCoreControlCreateInfoARM : return "DeviceQueueShaderCoreControlCreateInfoARM";
|
|
|
5217 case StructureType::ePhysicalDeviceSchedulingControlsFeaturesARM : return "PhysicalDeviceSchedulingControlsFeaturesARM";
|
|
|
5218 case StructureType::ePhysicalDeviceSchedulingControlsPropertiesARM : return "PhysicalDeviceSchedulingControlsPropertiesARM";
|
|
|
5219 case StructureType::ePhysicalDeviceImageSlicedViewOf3DFeaturesEXT : return "PhysicalDeviceImageSlicedViewOf3DFeaturesEXT";
|
|
|
5220 case StructureType::eImageViewSlicedCreateInfoEXT : return "ImageViewSlicedCreateInfoEXT";
|
|
|
5221 case StructureType::ePhysicalDeviceDescriptorSetHostMappingFeaturesVALVE : return "PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE";
|
|
|
5222 case StructureType::eDescriptorSetBindingReferenceVALVE : return "DescriptorSetBindingReferenceVALVE";
|
|
|
5223 case StructureType::eDescriptorSetLayoutHostMappingInfoVALVE : return "DescriptorSetLayoutHostMappingInfoVALVE";
|
|
|
5224 case StructureType::ePhysicalDeviceNonSeamlessCubeMapFeaturesEXT : return "PhysicalDeviceNonSeamlessCubeMapFeaturesEXT";
|
|
|
5225 case StructureType::ePhysicalDeviceRenderPassStripedFeaturesARM : return "PhysicalDeviceRenderPassStripedFeaturesARM";
|
|
|
5226 case StructureType::ePhysicalDeviceRenderPassStripedPropertiesARM : return "PhysicalDeviceRenderPassStripedPropertiesARM";
|
|
|
5227 case StructureType::eRenderPassStripeBeginInfoARM : return "RenderPassStripeBeginInfoARM";
|
|
|
5228 case StructureType::eRenderPassStripeInfoARM : return "RenderPassStripeInfoARM";
|
|
|
5229 case StructureType::eRenderPassStripeSubmitInfoARM : return "RenderPassStripeSubmitInfoARM";
|
|
|
5230 case StructureType::ePhysicalDeviceCopyMemoryIndirectFeaturesNV : return "PhysicalDeviceCopyMemoryIndirectFeaturesNV";
|
|
|
5231 case StructureType::ePhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV : return "PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV";
|
|
|
5232 case StructureType::eComputePipelineIndirectBufferInfoNV : return "ComputePipelineIndirectBufferInfoNV";
|
|
|
5233 case StructureType::ePipelineIndirectDeviceAddressInfoNV : return "PipelineIndirectDeviceAddressInfoNV";
|
|
|
5234 case StructureType::ePhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV : return "PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV";
|
|
|
5235 case StructureType::eAccelerationStructureGeometryLinearSweptSpheresDataNV : return "AccelerationStructureGeometryLinearSweptSpheresDataNV";
|
|
|
5236 case StructureType::eAccelerationStructureGeometrySpheresDataNV : return "AccelerationStructureGeometrySpheresDataNV";
|
|
|
5237 case StructureType::ePhysicalDeviceLinearColorAttachmentFeaturesNV : return "PhysicalDeviceLinearColorAttachmentFeaturesNV";
|
|
|
5238 case StructureType::ePhysicalDeviceShaderMaximalReconvergenceFeaturesKHR : return "PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR";
|
|
|
5239 case StructureType::ePhysicalDeviceImageCompressionControlSwapchainFeaturesEXT: return "PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT";
|
|
|
5240 case StructureType::ePhysicalDeviceImageProcessingFeaturesQCOM : return "PhysicalDeviceImageProcessingFeaturesQCOM";
|
|
|
5241 case StructureType::ePhysicalDeviceImageProcessingPropertiesQCOM : return "PhysicalDeviceImageProcessingPropertiesQCOM";
|
|
|
5242 case StructureType::eImageViewSampleWeightCreateInfoQCOM : return "ImageViewSampleWeightCreateInfoQCOM";
|
|
|
5243 case StructureType::ePhysicalDeviceNestedCommandBufferFeaturesEXT : return "PhysicalDeviceNestedCommandBufferFeaturesEXT";
|
|
|
5244 case StructureType::ePhysicalDeviceNestedCommandBufferPropertiesEXT : return "PhysicalDeviceNestedCommandBufferPropertiesEXT";
|
|
|
5245 #if defined( VK_USE_PLATFORM_OHOS )
|
|
|
5246 case StructureType::eNativeBufferUsageOHOS : return "NativeBufferUsageOHOS";
|
|
|
5247 case StructureType::eNativeBufferPropertiesOHOS : return "NativeBufferPropertiesOHOS";
|
|
|
5248 case StructureType::eNativeBufferFormatPropertiesOHOS: return "NativeBufferFormatPropertiesOHOS";
|
|
|
5249 case StructureType::eImportNativeBufferInfoOHOS : return "ImportNativeBufferInfoOHOS";
|
|
|
5250 case StructureType::eMemoryGetNativeBufferInfoOHOS : return "MemoryGetNativeBufferInfoOHOS";
|
|
|
5251 case StructureType::eExternalFormatOHOS : return "ExternalFormatOHOS";
|
|
|
5252 #endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
5253 case StructureType::eExternalMemoryAcquireUnmodifiedEXT : return "ExternalMemoryAcquireUnmodifiedEXT";
|
|
|
5254 case StructureType::ePhysicalDeviceExtendedDynamicState3FeaturesEXT : return "PhysicalDeviceExtendedDynamicState3FeaturesEXT";
|
|
|
5255 case StructureType::ePhysicalDeviceExtendedDynamicState3PropertiesEXT : return "PhysicalDeviceExtendedDynamicState3PropertiesEXT";
|
|
|
5256 case StructureType::ePhysicalDeviceSubpassMergeFeedbackFeaturesEXT : return "PhysicalDeviceSubpassMergeFeedbackFeaturesEXT";
|
|
|
5257 case StructureType::eRenderPassCreationControlEXT : return "RenderPassCreationControlEXT";
|
|
|
5258 case StructureType::eRenderPassCreationFeedbackCreateInfoEXT : return "RenderPassCreationFeedbackCreateInfoEXT";
|
|
|
5259 case StructureType::eRenderPassSubpassFeedbackCreateInfoEXT : return "RenderPassSubpassFeedbackCreateInfoEXT";
|
|
|
5260 case StructureType::eDirectDriverLoadingInfoLUNARG : return "DirectDriverLoadingInfoLUNARG";
|
|
|
5261 case StructureType::eDirectDriverLoadingListLUNARG : return "DirectDriverLoadingListLUNARG";
|
|
|
5262 case StructureType::eTensorCreateInfoARM : return "TensorCreateInfoARM";
|
|
|
5263 case StructureType::eTensorViewCreateInfoARM : return "TensorViewCreateInfoARM";
|
|
|
5264 case StructureType::eBindTensorMemoryInfoARM : return "BindTensorMemoryInfoARM";
|
|
|
5265 case StructureType::eWriteDescriptorSetTensorARM : return "WriteDescriptorSetTensorARM";
|
|
|
5266 case StructureType::ePhysicalDeviceTensorPropertiesARM : return "PhysicalDeviceTensorPropertiesARM";
|
|
|
5267 case StructureType::eTensorFormatPropertiesARM : return "TensorFormatPropertiesARM";
|
|
|
5268 case StructureType::eTensorDescriptionARM : return "TensorDescriptionARM";
|
|
|
5269 case StructureType::eTensorMemoryRequirementsInfoARM : return "TensorMemoryRequirementsInfoARM";
|
|
|
5270 case StructureType::eTensorMemoryBarrierARM : return "TensorMemoryBarrierARM";
|
|
|
5271 case StructureType::ePhysicalDeviceTensorFeaturesARM : return "PhysicalDeviceTensorFeaturesARM";
|
|
|
5272 case StructureType::eDeviceTensorMemoryRequirementsARM : return "DeviceTensorMemoryRequirementsARM";
|
|
|
5273 case StructureType::eCopyTensorInfoARM : return "CopyTensorInfoARM";
|
|
|
5274 case StructureType::eTensorCopyARM : return "TensorCopyARM";
|
|
|
5275 case StructureType::eTensorDependencyInfoARM : return "TensorDependencyInfoARM";
|
|
|
5276 case StructureType::eMemoryDedicatedAllocateInfoTensorARM : return "MemoryDedicatedAllocateInfoTensorARM";
|
|
|
5277 case StructureType::ePhysicalDeviceExternalTensorInfoARM : return "PhysicalDeviceExternalTensorInfoARM";
|
|
|
5278 case StructureType::eExternalTensorPropertiesARM : return "ExternalTensorPropertiesARM";
|
|
|
5279 case StructureType::eExternalMemoryTensorCreateInfoARM : return "ExternalMemoryTensorCreateInfoARM";
|
|
|
5280 case StructureType::ePhysicalDeviceDescriptorBufferTensorFeaturesARM : return "PhysicalDeviceDescriptorBufferTensorFeaturesARM";
|
|
|
5281 case StructureType::ePhysicalDeviceDescriptorBufferTensorPropertiesARM : return "PhysicalDeviceDescriptorBufferTensorPropertiesARM";
|
|
|
5282 case StructureType::eDescriptorGetTensorInfoARM : return "DescriptorGetTensorInfoARM";
|
|
|
5283 case StructureType::eTensorCaptureDescriptorDataInfoARM : return "TensorCaptureDescriptorDataInfoARM";
|
|
|
5284 case StructureType::eTensorViewCaptureDescriptorDataInfoARM : return "TensorViewCaptureDescriptorDataInfoARM";
|
|
|
5285 case StructureType::eFrameBoundaryTensorsARM : return "FrameBoundaryTensorsARM";
|
|
|
5286 case StructureType::ePhysicalDeviceShaderModuleIdentifierFeaturesEXT : return "PhysicalDeviceShaderModuleIdentifierFeaturesEXT";
|
|
|
5287 case StructureType::ePhysicalDeviceShaderModuleIdentifierPropertiesEXT : return "PhysicalDeviceShaderModuleIdentifierPropertiesEXT";
|
|
|
5288 case StructureType::ePipelineShaderStageModuleIdentifierCreateInfoEXT : return "PipelineShaderStageModuleIdentifierCreateInfoEXT";
|
|
|
5289 case StructureType::eShaderModuleIdentifierEXT : return "ShaderModuleIdentifierEXT";
|
|
|
5290 case StructureType::ePhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT: return "PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT";
|
|
|
5291 case StructureType::ePhysicalDeviceOpticalFlowFeaturesNV : return "PhysicalDeviceOpticalFlowFeaturesNV";
|
|
|
5292 case StructureType::ePhysicalDeviceOpticalFlowPropertiesNV : return "PhysicalDeviceOpticalFlowPropertiesNV";
|
|
|
5293 case StructureType::eOpticalFlowImageFormatInfoNV : return "OpticalFlowImageFormatInfoNV";
|
|
|
5294 case StructureType::eOpticalFlowImageFormatPropertiesNV : return "OpticalFlowImageFormatPropertiesNV";
|
|
|
5295 case StructureType::eOpticalFlowSessionCreateInfoNV : return "OpticalFlowSessionCreateInfoNV";
|
|
|
5296 case StructureType::eOpticalFlowExecuteInfoNV : return "OpticalFlowExecuteInfoNV";
|
|
|
5297 case StructureType::eOpticalFlowSessionCreatePrivateDataInfoNV : return "OpticalFlowSessionCreatePrivateDataInfoNV";
|
|
|
5298 case StructureType::ePhysicalDeviceLegacyDitheringFeaturesEXT : return "PhysicalDeviceLegacyDitheringFeaturesEXT";
|
|
|
5299 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
|
5300 case StructureType::ePhysicalDeviceExternalFormatResolveFeaturesANDROID : return "PhysicalDeviceExternalFormatResolveFeaturesANDROID";
|
|
|
5301 case StructureType::ePhysicalDeviceExternalFormatResolvePropertiesANDROID: return "PhysicalDeviceExternalFormatResolvePropertiesANDROID";
|
|
|
5302 case StructureType::eAndroidHardwareBufferFormatResolvePropertiesANDROID : return "AndroidHardwareBufferFormatResolvePropertiesANDROID";
|
|
|
5303 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
5304 case StructureType::ePhysicalDeviceAntiLagFeaturesAMD: return "PhysicalDeviceAntiLagFeaturesAMD";
|
|
|
5305 case StructureType::eAntiLagDataAMD : return "AntiLagDataAMD";
|
|
|
5306 case StructureType::eAntiLagPresentationInfoAMD : return "AntiLagPresentationInfoAMD";
|
|
|
5307 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
5308 case StructureType::ePhysicalDeviceDenseGeometryFormatFeaturesAMDX : return "PhysicalDeviceDenseGeometryFormatFeaturesAMDX";
|
|
|
5309 case StructureType::eAccelerationStructureDenseGeometryFormatTrianglesDataAMDX: return "AccelerationStructureDenseGeometryFormatTrianglesDataAMDX";
|
|
|
5310 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
5311 case StructureType::eSurfaceCapabilitiesPresentId2KHR : return "SurfaceCapabilitiesPresentId2KHR";
|
|
|
5312 case StructureType::ePresentId2KHR : return "PresentId2KHR";
|
|
|
5313 case StructureType::ePhysicalDevicePresentId2FeaturesKHR : return "PhysicalDevicePresentId2FeaturesKHR";
|
|
|
5314 case StructureType::eSurfaceCapabilitiesPresentWait2KHR : return "SurfaceCapabilitiesPresentWait2KHR";
|
|
|
5315 case StructureType::ePhysicalDevicePresentWait2FeaturesKHR : return "PhysicalDevicePresentWait2FeaturesKHR";
|
|
|
5316 case StructureType::ePresentWait2InfoKHR : return "PresentWait2InfoKHR";
|
|
|
5317 case StructureType::ePhysicalDeviceRayTracingPositionFetchFeaturesKHR : return "PhysicalDeviceRayTracingPositionFetchFeaturesKHR";
|
|
|
5318 case StructureType::ePhysicalDeviceShaderObjectFeaturesEXT : return "PhysicalDeviceShaderObjectFeaturesEXT";
|
|
|
5319 case StructureType::ePhysicalDeviceShaderObjectPropertiesEXT : return "PhysicalDeviceShaderObjectPropertiesEXT";
|
|
|
5320 case StructureType::eShaderCreateInfoEXT : return "ShaderCreateInfoEXT";
|
|
|
5321 case StructureType::ePhysicalDevicePipelineBinaryFeaturesKHR : return "PhysicalDevicePipelineBinaryFeaturesKHR";
|
|
|
5322 case StructureType::ePipelineBinaryCreateInfoKHR : return "PipelineBinaryCreateInfoKHR";
|
|
|
5323 case StructureType::ePipelineBinaryInfoKHR : return "PipelineBinaryInfoKHR";
|
|
|
5324 case StructureType::ePipelineBinaryKeyKHR : return "PipelineBinaryKeyKHR";
|
|
|
5325 case StructureType::ePhysicalDevicePipelineBinaryPropertiesKHR : return "PhysicalDevicePipelineBinaryPropertiesKHR";
|
|
|
5326 case StructureType::eReleaseCapturedPipelineDataInfoKHR : return "ReleaseCapturedPipelineDataInfoKHR";
|
|
|
5327 case StructureType::ePipelineBinaryDataInfoKHR : return "PipelineBinaryDataInfoKHR";
|
|
|
5328 case StructureType::ePipelineCreateInfoKHR : return "PipelineCreateInfoKHR";
|
|
|
5329 case StructureType::eDevicePipelineBinaryInternalCacheControlKHR : return "DevicePipelineBinaryInternalCacheControlKHR";
|
|
|
5330 case StructureType::ePipelineBinaryHandlesInfoKHR : return "PipelineBinaryHandlesInfoKHR";
|
|
|
5331 case StructureType::ePhysicalDeviceTilePropertiesFeaturesQCOM : return "PhysicalDeviceTilePropertiesFeaturesQCOM";
|
|
|
5332 case StructureType::eTilePropertiesQCOM : return "TilePropertiesQCOM";
|
|
|
5333 case StructureType::ePhysicalDeviceAmigoProfilingFeaturesSEC : return "PhysicalDeviceAmigoProfilingFeaturesSEC";
|
|
|
5334 case StructureType::eAmigoProfilingSubmitInfoSEC : return "AmigoProfilingSubmitInfoSEC";
|
|
|
5335 case StructureType::eSurfacePresentModeKHR : return "SurfacePresentModeKHR";
|
|
|
5336 case StructureType::eSurfacePresentScalingCapabilitiesKHR : return "SurfacePresentScalingCapabilitiesKHR";
|
|
|
5337 case StructureType::eSurfacePresentModeCompatibilityKHR : return "SurfacePresentModeCompatibilityKHR";
|
|
|
5338 case StructureType::ePhysicalDeviceSwapchainMaintenance1FeaturesKHR : return "PhysicalDeviceSwapchainMaintenance1FeaturesKHR";
|
|
|
5339 case StructureType::eSwapchainPresentFenceInfoKHR : return "SwapchainPresentFenceInfoKHR";
|
|
|
5340 case StructureType::eSwapchainPresentModesCreateInfoKHR : return "SwapchainPresentModesCreateInfoKHR";
|
|
|
5341 case StructureType::eSwapchainPresentModeInfoKHR : return "SwapchainPresentModeInfoKHR";
|
|
|
5342 case StructureType::eSwapchainPresentScalingCreateInfoKHR : return "SwapchainPresentScalingCreateInfoKHR";
|
|
|
5343 case StructureType::eReleaseSwapchainImagesInfoKHR : return "ReleaseSwapchainImagesInfoKHR";
|
|
|
5344 case StructureType::ePhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM : return "PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM";
|
|
|
5345 case StructureType::ePhysicalDeviceRayTracingInvocationReorderFeaturesNV : return "PhysicalDeviceRayTracingInvocationReorderFeaturesNV";
|
|
|
5346 case StructureType::ePhysicalDeviceRayTracingInvocationReorderPropertiesNV : return "PhysicalDeviceRayTracingInvocationReorderPropertiesNV";
|
|
|
5347 case StructureType::ePhysicalDeviceCooperativeVectorFeaturesNV : return "PhysicalDeviceCooperativeVectorFeaturesNV";
|
|
|
5348 case StructureType::ePhysicalDeviceCooperativeVectorPropertiesNV : return "PhysicalDeviceCooperativeVectorPropertiesNV";
|
|
|
5349 case StructureType::eCooperativeVectorPropertiesNV : return "CooperativeVectorPropertiesNV";
|
|
|
5350 case StructureType::eConvertCooperativeVectorMatrixInfoNV : return "ConvertCooperativeVectorMatrixInfoNV";
|
|
|
5351 case StructureType::ePhysicalDeviceExtendedSparseAddressSpaceFeaturesNV : return "PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV";
|
|
|
5352 case StructureType::ePhysicalDeviceExtendedSparseAddressSpacePropertiesNV : return "PhysicalDeviceExtendedSparseAddressSpacePropertiesNV";
|
|
|
5353 case StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesEXT : return "PhysicalDeviceMutableDescriptorTypeFeaturesEXT";
|
|
|
5354 case StructureType::eMutableDescriptorTypeCreateInfoEXT : return "MutableDescriptorTypeCreateInfoEXT";
|
|
|
5355 case StructureType::ePhysicalDeviceLegacyVertexAttributesFeaturesEXT : return "PhysicalDeviceLegacyVertexAttributesFeaturesEXT";
|
|
|
5356 case StructureType::ePhysicalDeviceLegacyVertexAttributesPropertiesEXT : return "PhysicalDeviceLegacyVertexAttributesPropertiesEXT";
|
|
|
5357 case StructureType::eLayerSettingsCreateInfoEXT : return "LayerSettingsCreateInfoEXT";
|
|
|
5358 case StructureType::ePhysicalDeviceShaderCoreBuiltinsFeaturesARM : return "PhysicalDeviceShaderCoreBuiltinsFeaturesARM";
|
|
|
5359 case StructureType::ePhysicalDeviceShaderCoreBuiltinsPropertiesARM : return "PhysicalDeviceShaderCoreBuiltinsPropertiesARM";
|
|
|
5360 case StructureType::ePhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT : return "PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT";
|
|
|
5361 case StructureType::ePhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT : return "PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT";
|
|
|
5362 case StructureType::eLatencySleepModeInfoNV : return "LatencySleepModeInfoNV";
|
|
|
5363 case StructureType::eLatencySleepInfoNV : return "LatencySleepInfoNV";
|
|
|
5364 case StructureType::eSetLatencyMarkerInfoNV : return "SetLatencyMarkerInfoNV";
|
|
|
5365 case StructureType::eGetLatencyMarkerInfoNV : return "GetLatencyMarkerInfoNV";
|
|
|
5366 case StructureType::eLatencyTimingsFrameReportNV : return "LatencyTimingsFrameReportNV";
|
|
|
5367 case StructureType::eLatencySubmissionPresentIdNV : return "LatencySubmissionPresentIdNV";
|
|
|
5368 case StructureType::eOutOfBandQueueTypeInfoNV : return "OutOfBandQueueTypeInfoNV";
|
|
|
5369 case StructureType::eSwapchainLatencyCreateInfoNV : return "SwapchainLatencyCreateInfoNV";
|
|
|
5370 case StructureType::eLatencySurfaceCapabilitiesNV : return "LatencySurfaceCapabilitiesNV";
|
|
|
5371 case StructureType::ePhysicalDeviceCooperativeMatrixFeaturesKHR : return "PhysicalDeviceCooperativeMatrixFeaturesKHR";
|
|
|
5372 case StructureType::eCooperativeMatrixPropertiesKHR : return "CooperativeMatrixPropertiesKHR";
|
|
|
5373 case StructureType::ePhysicalDeviceCooperativeMatrixPropertiesKHR : return "PhysicalDeviceCooperativeMatrixPropertiesKHR";
|
|
|
5374 case StructureType::eDataGraphPipelineCreateInfoARM : return "DataGraphPipelineCreateInfoARM";
|
|
|
5375 case StructureType::eDataGraphPipelineSessionCreateInfoARM : return "DataGraphPipelineSessionCreateInfoARM";
|
|
|
5376 case StructureType::eDataGraphPipelineResourceInfoARM : return "DataGraphPipelineResourceInfoARM";
|
|
|
5377 case StructureType::eDataGraphPipelineConstantARM : return "DataGraphPipelineConstantARM";
|
|
|
5378 case StructureType::eDataGraphPipelineSessionMemoryRequirementsInfoARM : return "DataGraphPipelineSessionMemoryRequirementsInfoARM";
|
|
|
5379 case StructureType::eBindDataGraphPipelineSessionMemoryInfoARM : return "BindDataGraphPipelineSessionMemoryInfoARM";
|
|
|
5380 case StructureType::ePhysicalDeviceDataGraphFeaturesARM : return "PhysicalDeviceDataGraphFeaturesARM";
|
|
|
5381 case StructureType::eDataGraphPipelineShaderModuleCreateInfoARM : return "DataGraphPipelineShaderModuleCreateInfoARM";
|
|
|
5382 case StructureType::eDataGraphPipelinePropertyQueryResultARM : return "DataGraphPipelinePropertyQueryResultARM";
|
|
|
5383 case StructureType::eDataGraphPipelineInfoARM : return "DataGraphPipelineInfoARM";
|
|
|
5384 case StructureType::eDataGraphPipelineCompilerControlCreateInfoARM : return "DataGraphPipelineCompilerControlCreateInfoARM";
|
|
|
5385 case StructureType::eDataGraphPipelineSessionBindPointRequirementsInfoARM : return "DataGraphPipelineSessionBindPointRequirementsInfoARM";
|
|
|
5386 case StructureType::eDataGraphPipelineSessionBindPointRequirementARM : return "DataGraphPipelineSessionBindPointRequirementARM";
|
|
|
5387 case StructureType::eDataGraphPipelineIdentifierCreateInfoARM : return "DataGraphPipelineIdentifierCreateInfoARM";
|
|
|
5388 case StructureType::eDataGraphPipelineDispatchInfoARM : return "DataGraphPipelineDispatchInfoARM";
|
|
|
5389 case StructureType::eDataGraphProcessingEngineCreateInfoARM : return "DataGraphProcessingEngineCreateInfoARM";
|
|
|
5390 case StructureType::eQueueFamilyDataGraphProcessingEnginePropertiesARM : return "QueueFamilyDataGraphProcessingEnginePropertiesARM";
|
|
|
5391 case StructureType::eQueueFamilyDataGraphPropertiesARM : return "QueueFamilyDataGraphPropertiesARM";
|
|
|
5392 case StructureType::ePhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM : return "PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM";
|
|
|
5393 case StructureType::eDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM: return "DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM";
|
|
|
5394 case StructureType::ePhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM : return "PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM";
|
|
|
5395 case StructureType::eMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM : return "MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM";
|
|
|
5396 case StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesKHR : return "PhysicalDeviceComputeShaderDerivativesFeaturesKHR";
|
|
|
5397 case StructureType::ePhysicalDeviceComputeShaderDerivativesPropertiesKHR : return "PhysicalDeviceComputeShaderDerivativesPropertiesKHR";
|
|
|
5398 case StructureType::eVideoDecodeAv1CapabilitiesKHR : return "VideoDecodeAv1CapabilitiesKHR";
|
|
|
5399 case StructureType::eVideoDecodeAv1PictureInfoKHR : return "VideoDecodeAv1PictureInfoKHR";
|
|
|
5400 case StructureType::eVideoDecodeAv1ProfileInfoKHR : return "VideoDecodeAv1ProfileInfoKHR";
|
|
|
5401 case StructureType::eVideoDecodeAv1SessionParametersCreateInfoKHR : return "VideoDecodeAv1SessionParametersCreateInfoKHR";
|
|
|
5402 case StructureType::eVideoDecodeAv1DpbSlotInfoKHR : return "VideoDecodeAv1DpbSlotInfoKHR";
|
|
|
5403 case StructureType::eVideoEncodeAv1CapabilitiesKHR : return "VideoEncodeAv1CapabilitiesKHR";
|
|
|
5404 case StructureType::eVideoEncodeAv1SessionParametersCreateInfoKHR : return "VideoEncodeAv1SessionParametersCreateInfoKHR";
|
|
|
5405 case StructureType::eVideoEncodeAv1PictureInfoKHR : return "VideoEncodeAv1PictureInfoKHR";
|
|
|
5406 case StructureType::eVideoEncodeAv1DpbSlotInfoKHR : return "VideoEncodeAv1DpbSlotInfoKHR";
|
|
|
5407 case StructureType::ePhysicalDeviceVideoEncodeAv1FeaturesKHR : return "PhysicalDeviceVideoEncodeAv1FeaturesKHR";
|
|
|
5408 case StructureType::eVideoEncodeAv1ProfileInfoKHR : return "VideoEncodeAv1ProfileInfoKHR";
|
|
|
5409 case StructureType::eVideoEncodeAv1RateControlInfoKHR : return "VideoEncodeAv1RateControlInfoKHR";
|
|
|
5410 case StructureType::eVideoEncodeAv1RateControlLayerInfoKHR : return "VideoEncodeAv1RateControlLayerInfoKHR";
|
|
|
5411 case StructureType::eVideoEncodeAv1QualityLevelPropertiesKHR : return "VideoEncodeAv1QualityLevelPropertiesKHR";
|
|
|
5412 case StructureType::eVideoEncodeAv1SessionCreateInfoKHR : return "VideoEncodeAv1SessionCreateInfoKHR";
|
|
|
5413 case StructureType::eVideoEncodeAv1GopRemainingFrameInfoKHR : return "VideoEncodeAv1GopRemainingFrameInfoKHR";
|
|
|
5414 case StructureType::ePhysicalDeviceVideoDecodeVp9FeaturesKHR : return "PhysicalDeviceVideoDecodeVp9FeaturesKHR";
|
|
|
5415 case StructureType::eVideoDecodeVp9CapabilitiesKHR : return "VideoDecodeVp9CapabilitiesKHR";
|
|
|
5416 case StructureType::eVideoDecodeVp9PictureInfoKHR : return "VideoDecodeVp9PictureInfoKHR";
|
|
|
5417 case StructureType::eVideoDecodeVp9ProfileInfoKHR : return "VideoDecodeVp9ProfileInfoKHR";
|
|
|
5418 case StructureType::ePhysicalDeviceVideoMaintenance1FeaturesKHR : return "PhysicalDeviceVideoMaintenance1FeaturesKHR";
|
|
|
5419 case StructureType::eVideoInlineQueryInfoKHR : return "VideoInlineQueryInfoKHR";
|
|
|
5420 case StructureType::ePhysicalDevicePerStageDescriptorSetFeaturesNV : return "PhysicalDevicePerStageDescriptorSetFeaturesNV";
|
|
|
5421 case StructureType::ePhysicalDeviceImageProcessing2FeaturesQCOM : return "PhysicalDeviceImageProcessing2FeaturesQCOM";
|
|
|
5422 case StructureType::ePhysicalDeviceImageProcessing2PropertiesQCOM : return "PhysicalDeviceImageProcessing2PropertiesQCOM";
|
|
|
5423 case StructureType::eSamplerBlockMatchWindowCreateInfoQCOM : return "SamplerBlockMatchWindowCreateInfoQCOM";
|
|
|
5424 case StructureType::eSamplerCubicWeightsCreateInfoQCOM : return "SamplerCubicWeightsCreateInfoQCOM";
|
|
|
5425 case StructureType::ePhysicalDeviceCubicWeightsFeaturesQCOM : return "PhysicalDeviceCubicWeightsFeaturesQCOM";
|
|
|
5426 case StructureType::eBlitImageCubicWeightsInfoQCOM : return "BlitImageCubicWeightsInfoQCOM";
|
|
|
5427 case StructureType::ePhysicalDeviceYcbcrDegammaFeaturesQCOM : return "PhysicalDeviceYcbcrDegammaFeaturesQCOM";
|
|
|
5428 case StructureType::eSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM : return "SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM";
|
|
|
5429 case StructureType::ePhysicalDeviceCubicClampFeaturesQCOM : return "PhysicalDeviceCubicClampFeaturesQCOM";
|
|
|
5430 case StructureType::ePhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT : return "PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT";
|
|
|
5431 case StructureType::ePhysicalDeviceUnifiedImageLayoutsFeaturesKHR : return "PhysicalDeviceUnifiedImageLayoutsFeaturesKHR";
|
|
|
5432 case StructureType::eAttachmentFeedbackLoopInfoEXT : return "AttachmentFeedbackLoopInfoEXT";
|
|
|
5433 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
|
5434 case StructureType::eScreenBufferPropertiesQNX : return "ScreenBufferPropertiesQNX";
|
|
|
5435 case StructureType::eScreenBufferFormatPropertiesQNX : return "ScreenBufferFormatPropertiesQNX";
|
|
|
5436 case StructureType::eImportScreenBufferInfoQNX : return "ImportScreenBufferInfoQNX";
|
|
|
5437 case StructureType::eExternalFormatQNX : return "ExternalFormatQNX";
|
|
|
5438 case StructureType::ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX: return "PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX";
|
|
|
5439 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
|
5440 case StructureType::ePhysicalDeviceLayeredDriverPropertiesMSFT : return "PhysicalDeviceLayeredDriverPropertiesMSFT";
|
|
|
5441 case StructureType::eCalibratedTimestampInfoKHR : return "CalibratedTimestampInfoKHR";
|
|
|
5442 case StructureType::eSetDescriptorBufferOffsetsInfoEXT : return "SetDescriptorBufferOffsetsInfoEXT";
|
|
|
5443 case StructureType::eBindDescriptorBufferEmbeddedSamplersInfoEXT : return "BindDescriptorBufferEmbeddedSamplersInfoEXT";
|
|
|
5444 case StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV : return "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV";
|
|
|
5445 case StructureType::ePhysicalDeviceTileMemoryHeapFeaturesQCOM : return "PhysicalDeviceTileMemoryHeapFeaturesQCOM";
|
|
|
5446 case StructureType::ePhysicalDeviceTileMemoryHeapPropertiesQCOM : return "PhysicalDeviceTileMemoryHeapPropertiesQCOM";
|
|
|
5447 case StructureType::eTileMemoryRequirementsQCOM : return "TileMemoryRequirementsQCOM";
|
|
|
5448 case StructureType::eTileMemoryBindInfoQCOM : return "TileMemoryBindInfoQCOM";
|
|
|
5449 case StructureType::eTileMemorySizeInfoQCOM : return "TileMemorySizeInfoQCOM";
|
|
|
5450 case StructureType::ePhysicalDeviceCopyMemoryIndirectFeaturesKHR : return "PhysicalDeviceCopyMemoryIndirectFeaturesKHR";
|
|
|
5451 case StructureType::ePhysicalDeviceCopyMemoryIndirectPropertiesKHR : return "PhysicalDeviceCopyMemoryIndirectPropertiesKHR";
|
|
|
5452 case StructureType::eCopyMemoryIndirectInfoKHR : return "CopyMemoryIndirectInfoKHR";
|
|
|
5453 case StructureType::eCopyMemoryToImageIndirectInfoKHR : return "CopyMemoryToImageIndirectInfoKHR";
|
|
|
5454 case StructureType::ePhysicalDeviceMemoryDecompressionFeaturesEXT : return "PhysicalDeviceMemoryDecompressionFeaturesEXT";
|
|
|
5455 case StructureType::ePhysicalDeviceMemoryDecompressionPropertiesEXT : return "PhysicalDeviceMemoryDecompressionPropertiesEXT";
|
|
|
5456 case StructureType::eDecompressMemoryInfoEXT : return "DecompressMemoryInfoEXT";
|
|
|
5457 case StructureType::eDisplaySurfaceStereoCreateInfoNV : return "DisplaySurfaceStereoCreateInfoNV";
|
|
|
5458 case StructureType::eDisplayModeStereoPropertiesNV : return "DisplayModeStereoPropertiesNV";
|
|
|
5459 case StructureType::eVideoEncodeIntraRefreshCapabilitiesKHR : return "VideoEncodeIntraRefreshCapabilitiesKHR";
|
|
|
5460 case StructureType::eVideoEncodeSessionIntraRefreshCreateInfoKHR : return "VideoEncodeSessionIntraRefreshCreateInfoKHR";
|
|
|
5461 case StructureType::eVideoEncodeIntraRefreshInfoKHR : return "VideoEncodeIntraRefreshInfoKHR";
|
|
|
5462 case StructureType::eVideoReferenceIntraRefreshInfoKHR : return "VideoReferenceIntraRefreshInfoKHR";
|
|
|
5463 case StructureType::ePhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR : return "PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR";
|
|
|
5464 case StructureType::eVideoEncodeQuantizationMapCapabilitiesKHR : return "VideoEncodeQuantizationMapCapabilitiesKHR";
|
|
|
5465 case StructureType::eVideoFormatQuantizationMapPropertiesKHR : return "VideoFormatQuantizationMapPropertiesKHR";
|
|
|
5466 case StructureType::eVideoEncodeQuantizationMapInfoKHR : return "VideoEncodeQuantizationMapInfoKHR";
|
|
|
5467 case StructureType::eVideoEncodeQuantizationMapSessionParametersCreateInfoKHR : return "VideoEncodeQuantizationMapSessionParametersCreateInfoKHR";
|
|
|
5468 case StructureType::ePhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR : return "PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR";
|
|
|
5469 case StructureType::eVideoEncodeH264QuantizationMapCapabilitiesKHR : return "VideoEncodeH264QuantizationMapCapabilitiesKHR";
|
|
|
5470 case StructureType::eVideoEncodeH265QuantizationMapCapabilitiesKHR : return "VideoEncodeH265QuantizationMapCapabilitiesKHR";
|
|
|
5471 case StructureType::eVideoFormatH265QuantizationMapPropertiesKHR : return "VideoFormatH265QuantizationMapPropertiesKHR";
|
|
|
5472 case StructureType::eVideoEncodeAv1QuantizationMapCapabilitiesKHR : return "VideoEncodeAv1QuantizationMapCapabilitiesKHR";
|
|
|
5473 case StructureType::eVideoFormatAv1QuantizationMapPropertiesKHR : return "VideoFormatAv1QuantizationMapPropertiesKHR";
|
|
|
5474 case StructureType::ePhysicalDeviceRawAccessChainsFeaturesNV : return "PhysicalDeviceRawAccessChainsFeaturesNV";
|
|
|
5475 case StructureType::eExternalComputeQueueDeviceCreateInfoNV : return "ExternalComputeQueueDeviceCreateInfoNV";
|
|
|
5476 case StructureType::eExternalComputeQueueCreateInfoNV : return "ExternalComputeQueueCreateInfoNV";
|
|
|
5477 case StructureType::eExternalComputeQueueDataParamsNV : return "ExternalComputeQueueDataParamsNV";
|
|
|
5478 case StructureType::ePhysicalDeviceExternalComputeQueuePropertiesNV : return "PhysicalDeviceExternalComputeQueuePropertiesNV";
|
|
|
5479 case StructureType::ePhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR : return "PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR";
|
|
|
5480 case StructureType::ePhysicalDeviceCommandBufferInheritanceFeaturesNV : return "PhysicalDeviceCommandBufferInheritanceFeaturesNV";
|
|
|
5481 case StructureType::ePhysicalDeviceMaintenance7FeaturesKHR : return "PhysicalDeviceMaintenance7FeaturesKHR";
|
|
|
5482 case StructureType::ePhysicalDeviceMaintenance7PropertiesKHR : return "PhysicalDeviceMaintenance7PropertiesKHR";
|
|
|
5483 case StructureType::ePhysicalDeviceLayeredApiPropertiesListKHR : return "PhysicalDeviceLayeredApiPropertiesListKHR";
|
|
|
5484 case StructureType::ePhysicalDeviceLayeredApiPropertiesKHR : return "PhysicalDeviceLayeredApiPropertiesKHR";
|
|
|
5485 case StructureType::ePhysicalDeviceLayeredApiVulkanPropertiesKHR : return "PhysicalDeviceLayeredApiVulkanPropertiesKHR";
|
|
|
5486 case StructureType::ePhysicalDeviceShaderAtomicFloat16VectorFeaturesNV : return "PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV";
|
|
|
5487 case StructureType::ePhysicalDeviceShaderReplicatedCompositesFeaturesEXT : return "PhysicalDeviceShaderReplicatedCompositesFeaturesEXT";
|
|
|
5488 case StructureType::ePhysicalDeviceShaderFloat8FeaturesEXT : return "PhysicalDeviceShaderFloat8FeaturesEXT";
|
|
|
5489 case StructureType::ePhysicalDeviceRayTracingValidationFeaturesNV : return "PhysicalDeviceRayTracingValidationFeaturesNV";
|
|
|
5490 case StructureType::ePhysicalDeviceClusterAccelerationStructureFeaturesNV : return "PhysicalDeviceClusterAccelerationStructureFeaturesNV";
|
|
|
5491 case StructureType::ePhysicalDeviceClusterAccelerationStructurePropertiesNV : return "PhysicalDeviceClusterAccelerationStructurePropertiesNV";
|
|
|
5492 case StructureType::eClusterAccelerationStructureClustersBottomLevelInputNV : return "ClusterAccelerationStructureClustersBottomLevelInputNV";
|
|
|
5493 case StructureType::eClusterAccelerationStructureTriangleClusterInputNV : return "ClusterAccelerationStructureTriangleClusterInputNV";
|
|
|
5494 case StructureType::eClusterAccelerationStructureMoveObjectsInputNV : return "ClusterAccelerationStructureMoveObjectsInputNV";
|
|
|
5495 case StructureType::eClusterAccelerationStructureInputInfoNV : return "ClusterAccelerationStructureInputInfoNV";
|
|
|
5496 case StructureType::eClusterAccelerationStructureCommandsInfoNV : return "ClusterAccelerationStructureCommandsInfoNV";
|
|
|
5497 case StructureType::eRayTracingPipelineClusterAccelerationStructureCreateInfoNV: return "RayTracingPipelineClusterAccelerationStructureCreateInfoNV";
|
|
|
5498 case StructureType::ePhysicalDevicePartitionedAccelerationStructureFeaturesNV : return "PhysicalDevicePartitionedAccelerationStructureFeaturesNV";
|
|
|
5499 case StructureType::ePhysicalDevicePartitionedAccelerationStructurePropertiesNV: return "PhysicalDevicePartitionedAccelerationStructurePropertiesNV";
|
|
|
5500 case StructureType::eWriteDescriptorSetPartitionedAccelerationStructureNV : return "WriteDescriptorSetPartitionedAccelerationStructureNV";
|
|
|
5501 case StructureType::ePartitionedAccelerationStructureInstancesInputNV : return "PartitionedAccelerationStructureInstancesInputNV";
|
|
|
5502 case StructureType::eBuildPartitionedAccelerationStructureInfoNV : return "BuildPartitionedAccelerationStructureInfoNV";
|
|
|
5503 case StructureType::ePartitionedAccelerationStructureFlagsNV : return "PartitionedAccelerationStructureFlagsNV";
|
|
|
5504 case StructureType::ePhysicalDeviceDeviceGeneratedCommandsFeaturesEXT : return "PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT";
|
|
|
5505 case StructureType::ePhysicalDeviceDeviceGeneratedCommandsPropertiesEXT : return "PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT";
|
|
|
5506 case StructureType::eGeneratedCommandsMemoryRequirementsInfoEXT : return "GeneratedCommandsMemoryRequirementsInfoEXT";
|
|
|
5507 case StructureType::eIndirectExecutionSetCreateInfoEXT : return "IndirectExecutionSetCreateInfoEXT";
|
|
|
5508 case StructureType::eGeneratedCommandsInfoEXT : return "GeneratedCommandsInfoEXT";
|
|
|
5509 case StructureType::eIndirectCommandsLayoutCreateInfoEXT : return "IndirectCommandsLayoutCreateInfoEXT";
|
|
|
5510 case StructureType::eIndirectCommandsLayoutTokenEXT : return "IndirectCommandsLayoutTokenEXT";
|
|
|
5511 case StructureType::eWriteIndirectExecutionSetPipelineEXT : return "WriteIndirectExecutionSetPipelineEXT";
|
|
|
5512 case StructureType::eWriteIndirectExecutionSetShaderEXT : return "WriteIndirectExecutionSetShaderEXT";
|
|
|
5513 case StructureType::eIndirectExecutionSetPipelineInfoEXT : return "IndirectExecutionSetPipelineInfoEXT";
|
|
|
5514 case StructureType::eIndirectExecutionSetShaderInfoEXT : return "IndirectExecutionSetShaderInfoEXT";
|
|
|
5515 case StructureType::eIndirectExecutionSetShaderLayoutInfoEXT : return "IndirectExecutionSetShaderLayoutInfoEXT";
|
|
|
5516 case StructureType::eGeneratedCommandsPipelineInfoEXT : return "GeneratedCommandsPipelineInfoEXT";
|
|
|
5517 case StructureType::eGeneratedCommandsShaderInfoEXT : return "GeneratedCommandsShaderInfoEXT";
|
|
|
5518 case StructureType::ePhysicalDeviceMaintenance8FeaturesKHR : return "PhysicalDeviceMaintenance8FeaturesKHR";
|
|
|
5519 case StructureType::eMemoryBarrierAccessFlags3KHR : return "MemoryBarrierAccessFlags3KHR";
|
|
|
5520 case StructureType::ePhysicalDeviceImageAlignmentControlFeaturesMESA : return "PhysicalDeviceImageAlignmentControlFeaturesMESA";
|
|
|
5521 case StructureType::ePhysicalDeviceImageAlignmentControlPropertiesMESA : return "PhysicalDeviceImageAlignmentControlPropertiesMESA";
|
|
|
5522 case StructureType::eImageAlignmentControlCreateInfoMESA : return "ImageAlignmentControlCreateInfoMESA";
|
|
|
5523 case StructureType::ePhysicalDeviceShaderFmaFeaturesKHR : return "PhysicalDeviceShaderFmaFeaturesKHR";
|
|
|
5524 case StructureType::ePhysicalDeviceRayTracingInvocationReorderFeaturesEXT : return "PhysicalDeviceRayTracingInvocationReorderFeaturesEXT";
|
|
|
5525 case StructureType::ePhysicalDeviceRayTracingInvocationReorderPropertiesEXT : return "PhysicalDeviceRayTracingInvocationReorderPropertiesEXT";
|
|
|
5526 case StructureType::ePhysicalDeviceDepthClampControlFeaturesEXT : return "PhysicalDeviceDepthClampControlFeaturesEXT";
|
|
|
5527 case StructureType::ePipelineViewportDepthClampControlCreateInfoEXT : return "PipelineViewportDepthClampControlCreateInfoEXT";
|
|
|
5528 case StructureType::ePhysicalDeviceMaintenance9FeaturesKHR : return "PhysicalDeviceMaintenance9FeaturesKHR";
|
|
|
5529 case StructureType::ePhysicalDeviceMaintenance9PropertiesKHR : return "PhysicalDeviceMaintenance9PropertiesKHR";
|
|
|
5530 case StructureType::eQueueFamilyOwnershipTransferPropertiesKHR : return "QueueFamilyOwnershipTransferPropertiesKHR";
|
|
|
5531 case StructureType::ePhysicalDeviceVideoMaintenance2FeaturesKHR : return "PhysicalDeviceVideoMaintenance2FeaturesKHR";
|
|
|
5532 case StructureType::eVideoDecodeH264InlineSessionParametersInfoKHR : return "VideoDecodeH264InlineSessionParametersInfoKHR";
|
|
|
5533 case StructureType::eVideoDecodeH265InlineSessionParametersInfoKHR : return "VideoDecodeH265InlineSessionParametersInfoKHR";
|
|
|
5534 case StructureType::eVideoDecodeAv1InlineSessionParametersInfoKHR : return "VideoDecodeAv1InlineSessionParametersInfoKHR";
|
|
|
5535 #if defined( VK_USE_PLATFORM_OHOS )
|
|
|
5536 case StructureType::eSurfaceCreateInfoOHOS : return "SurfaceCreateInfoOHOS";
|
|
|
5537 case StructureType::eNativeBufferOHOS : return "NativeBufferOHOS";
|
|
|
5538 case StructureType::eSwapchainImageCreateInfoOHOS : return "SwapchainImageCreateInfoOHOS";
|
|
|
5539 case StructureType::ePhysicalDevicePresentationPropertiesOHOS: return "PhysicalDevicePresentationPropertiesOHOS";
|
|
|
5540 #endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
5541 case StructureType::ePhysicalDeviceHdrVividFeaturesHUAWEI : return "PhysicalDeviceHdrVividFeaturesHUAWEI";
|
|
|
5542 case StructureType::eHdrVividDynamicMetadataHUAWEI : return "HdrVividDynamicMetadataHUAWEI";
|
|
|
5543 case StructureType::ePhysicalDeviceCooperativeMatrix2FeaturesNV : return "PhysicalDeviceCooperativeMatrix2FeaturesNV";
|
|
|
5544 case StructureType::eCooperativeMatrixFlexibleDimensionsPropertiesNV : return "CooperativeMatrixFlexibleDimensionsPropertiesNV";
|
|
|
5545 case StructureType::ePhysicalDeviceCooperativeMatrix2PropertiesNV : return "PhysicalDeviceCooperativeMatrix2PropertiesNV";
|
|
|
5546 case StructureType::ePhysicalDevicePipelineOpacityMicromapFeaturesARM: return "PhysicalDevicePipelineOpacityMicromapFeaturesARM";
|
|
|
5547 #if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
5548 case StructureType::eImportMemoryMetalHandleInfoEXT: return "ImportMemoryMetalHandleInfoEXT";
|
|
|
5549 case StructureType::eMemoryMetalHandlePropertiesEXT: return "MemoryMetalHandlePropertiesEXT";
|
|
|
5550 case StructureType::eMemoryGetMetalHandleInfoEXT : return "MemoryGetMetalHandleInfoEXT";
|
|
|
5551 #endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
5552 case StructureType::ePhysicalDeviceDepthClampZeroOneFeaturesKHR : return "PhysicalDeviceDepthClampZeroOneFeaturesKHR";
|
|
|
5553 case StructureType::ePhysicalDevicePerformanceCountersByRegionFeaturesARM : return "PhysicalDevicePerformanceCountersByRegionFeaturesARM";
|
|
|
5554 case StructureType::ePhysicalDevicePerformanceCountersByRegionPropertiesARM: return "PhysicalDevicePerformanceCountersByRegionPropertiesARM";
|
|
|
5555 case StructureType::ePerformanceCounterARM : return "PerformanceCounterARM";
|
|
|
5556 case StructureType::ePerformanceCounterDescriptionARM : return "PerformanceCounterDescriptionARM";
|
|
|
5557 case StructureType::eRenderPassPerformanceCountersByRegionBeginInfoARM : return "RenderPassPerformanceCountersByRegionBeginInfoARM";
|
|
|
5558 case StructureType::ePhysicalDeviceVertexAttributeRobustnessFeaturesEXT : return "PhysicalDeviceVertexAttributeRobustnessFeaturesEXT";
|
|
|
5559 case StructureType::ePhysicalDeviceFormatPackFeaturesARM : return "PhysicalDeviceFormatPackFeaturesARM";
|
|
|
5560 case StructureType::ePhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE : return "PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE";
|
|
|
5561 case StructureType::ePhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE: return "PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE";
|
|
|
5562 case StructureType::ePipelineFragmentDensityMapLayeredCreateInfoVALVE : return "PipelineFragmentDensityMapLayeredCreateInfoVALVE";
|
|
|
5563 case StructureType::ePhysicalDeviceRobustness2FeaturesKHR : return "PhysicalDeviceRobustness2FeaturesKHR";
|
|
|
5564 case StructureType::ePhysicalDeviceRobustness2PropertiesKHR : return "PhysicalDeviceRobustness2PropertiesKHR";
|
|
|
5565 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
5566 case StructureType::eSetPresentConfigNV : return "SetPresentConfigNV";
|
|
|
5567 case StructureType::ePhysicalDevicePresentMeteringFeaturesNV: return "PhysicalDevicePresentMeteringFeaturesNV";
|
|
|
5568 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
5569 case StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesEXT : return "PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT";
|
|
|
5570 case StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesEXT : return "PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT";
|
|
|
5571 case StructureType::eRenderPassFragmentDensityMapOffsetEndInfoEXT : return "RenderPassFragmentDensityMapOffsetEndInfoEXT";
|
|
|
5572 case StructureType::ePhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT : return "PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT";
|
|
|
5573 case StructureType::ePhysicalDevicePresentModeFifoLatestReadyFeaturesKHR : return "PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR";
|
|
|
5574 case StructureType::ePhysicalDeviceShader64BitIndexingFeaturesEXT : return "PhysicalDeviceShader64BitIndexingFeaturesEXT";
|
|
|
5575 case StructureType::ePhysicalDeviceCustomResolveFeaturesEXT : return "PhysicalDeviceCustomResolveFeaturesEXT";
|
|
|
5576 case StructureType::eBeginCustomResolveInfoEXT : return "BeginCustomResolveInfoEXT";
|
|
|
5577 case StructureType::eCustomResolveCreateInfoEXT : return "CustomResolveCreateInfoEXT";
|
|
|
5578 case StructureType::ePhysicalDeviceDataGraphModelFeaturesQCOM : return "PhysicalDeviceDataGraphModelFeaturesQCOM";
|
|
|
5579 case StructureType::eDataGraphPipelineBuiltinModelCreateInfoQCOM : return "DataGraphPipelineBuiltinModelCreateInfoQCOM";
|
|
|
5580 case StructureType::ePhysicalDeviceMaintenance10FeaturesKHR : return "PhysicalDeviceMaintenance10FeaturesKHR";
|
|
|
5581 case StructureType::ePhysicalDeviceMaintenance10PropertiesKHR : return "PhysicalDeviceMaintenance10PropertiesKHR";
|
|
|
5582 case StructureType::eRenderingAttachmentFlagsInfoKHR : return "RenderingAttachmentFlagsInfoKHR";
|
|
|
5583 case StructureType::eRenderingEndInfoKHR : return "RenderingEndInfoKHR";
|
|
|
5584 case StructureType::eResolveImageModeInfoKHR : return "ResolveImageModeInfoKHR";
|
|
|
5585 case StructureType::ePhysicalDevicePipelineCacheIncrementalModeFeaturesSEC : return "PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC";
|
|
|
5586 case StructureType::ePhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT: return "PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT";
|
|
|
5587 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
5588 }
|
|
|
5589 }
|
|
|
5590
|
|
|
5591 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ObjectType value )
|
|
|
5592 {
|
|
|
5593 switch ( value )
|
|
|
5594 {
|
|
|
5595 case ObjectType::eUnknown : return "Unknown";
|
|
|
5596 case ObjectType::eInstance : return "Instance";
|
|
|
5597 case ObjectType::ePhysicalDevice : return "PhysicalDevice";
|
|
|
5598 case ObjectType::eDevice : return "Device";
|
|
|
5599 case ObjectType::eQueue : return "Queue";
|
|
|
5600 case ObjectType::eSemaphore : return "Semaphore";
|
|
|
5601 case ObjectType::eCommandBuffer : return "CommandBuffer";
|
|
|
5602 case ObjectType::eFence : return "Fence";
|
|
|
5603 case ObjectType::eDeviceMemory : return "DeviceMemory";
|
|
|
5604 case ObjectType::eBuffer : return "Buffer";
|
|
|
5605 case ObjectType::eImage : return "Image";
|
|
|
5606 case ObjectType::eEvent : return "Event";
|
|
|
5607 case ObjectType::eQueryPool : return "QueryPool";
|
|
|
5608 case ObjectType::eBufferView : return "BufferView";
|
|
|
5609 case ObjectType::eImageView : return "ImageView";
|
|
|
5610 case ObjectType::eShaderModule : return "ShaderModule";
|
|
|
5611 case ObjectType::ePipelineCache : return "PipelineCache";
|
|
|
5612 case ObjectType::ePipelineLayout : return "PipelineLayout";
|
|
|
5613 case ObjectType::eRenderPass : return "RenderPass";
|
|
|
5614 case ObjectType::ePipeline : return "Pipeline";
|
|
|
5615 case ObjectType::eDescriptorSetLayout : return "DescriptorSetLayout";
|
|
|
5616 case ObjectType::eSampler : return "Sampler";
|
|
|
5617 case ObjectType::eDescriptorPool : return "DescriptorPool";
|
|
|
5618 case ObjectType::eDescriptorSet : return "DescriptorSet";
|
|
|
5619 case ObjectType::eFramebuffer : return "Framebuffer";
|
|
|
5620 case ObjectType::eCommandPool : return "CommandPool";
|
|
|
5621 case ObjectType::eDescriptorUpdateTemplate : return "DescriptorUpdateTemplate";
|
|
|
5622 case ObjectType::eSamplerYcbcrConversion : return "SamplerYcbcrConversion";
|
|
|
5623 case ObjectType::ePrivateDataSlot : return "PrivateDataSlot";
|
|
|
5624 case ObjectType::eSurfaceKHR : return "SurfaceKHR";
|
|
|
5625 case ObjectType::eSwapchainKHR : return "SwapchainKHR";
|
|
|
5626 case ObjectType::eDisplayKHR : return "DisplayKHR";
|
|
|
5627 case ObjectType::eDisplayModeKHR : return "DisplayModeKHR";
|
|
|
5628 case ObjectType::eDebugReportCallbackEXT : return "DebugReportCallbackEXT";
|
|
|
5629 case ObjectType::eVideoSessionKHR : return "VideoSessionKHR";
|
|
|
5630 case ObjectType::eVideoSessionParametersKHR : return "VideoSessionParametersKHR";
|
|
|
5631 case ObjectType::eCuModuleNVX : return "CuModuleNVX";
|
|
|
5632 case ObjectType::eCuFunctionNVX : return "CuFunctionNVX";
|
|
|
5633 case ObjectType::eDebugUtilsMessengerEXT : return "DebugUtilsMessengerEXT";
|
|
|
5634 case ObjectType::eAccelerationStructureKHR : return "AccelerationStructureKHR";
|
|
|
5635 case ObjectType::eValidationCacheEXT : return "ValidationCacheEXT";
|
|
|
5636 case ObjectType::eAccelerationStructureNV : return "AccelerationStructureNV";
|
|
|
5637 case ObjectType::ePerformanceConfigurationINTEL: return "PerformanceConfigurationINTEL";
|
|
|
5638 case ObjectType::eDeferredOperationKHR : return "DeferredOperationKHR";
|
|
|
5639 case ObjectType::eIndirectCommandsLayoutNV : return "IndirectCommandsLayoutNV";
|
|
|
5640 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
5641 case ObjectType::eCudaModuleNV : return "CudaModuleNV";
|
|
|
5642 case ObjectType::eCudaFunctionNV: return "CudaFunctionNV";
|
|
|
5643 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
5644 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
5645 case ObjectType::eBufferCollectionFUCHSIA: return "BufferCollectionFUCHSIA";
|
|
|
5646 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
5647 case ObjectType::eMicromapEXT : return "MicromapEXT";
|
|
|
5648 case ObjectType::eTensorARM : return "TensorARM";
|
|
|
5649 case ObjectType::eTensorViewARM : return "TensorViewARM";
|
|
|
5650 case ObjectType::eOpticalFlowSessionNV : return "OpticalFlowSessionNV";
|
|
|
5651 case ObjectType::eShaderEXT : return "ShaderEXT";
|
|
|
5652 case ObjectType::ePipelineBinaryKHR : return "PipelineBinaryKHR";
|
|
|
5653 case ObjectType::eDataGraphPipelineSessionARM: return "DataGraphPipelineSessionARM";
|
|
|
5654 case ObjectType::eExternalComputeQueueNV : return "ExternalComputeQueueNV";
|
|
|
5655 case ObjectType::eIndirectCommandsLayoutEXT : return "IndirectCommandsLayoutEXT";
|
|
|
5656 case ObjectType::eIndirectExecutionSetEXT : return "IndirectExecutionSetEXT";
|
|
|
5657 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
5658 }
|
|
|
5659 }
|
|
|
5660
|
|
|
5661 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VendorId value )
|
|
|
5662 {
|
|
|
5663 switch ( value )
|
|
|
5664 {
|
|
|
5665 case VendorId::eKhronos : return "Khronos";
|
|
|
5666 case VendorId::eVIV : return "VIV";
|
|
|
5667 case VendorId::eVSI : return "VSI";
|
|
|
5668 case VendorId::eKazan : return "Kazan";
|
|
|
5669 case VendorId::eCodeplay: return "Codeplay";
|
|
|
5670 case VendorId::eMESA : return "MESA";
|
|
|
5671 case VendorId::ePocl : return "Pocl";
|
|
|
5672 case VendorId::eMobileye: return "Mobileye";
|
|
|
5673 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
5674 }
|
|
|
5675 }
|
|
|
5676
|
|
|
5677 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( Format value )
|
|
|
5678 {
|
|
|
5679 switch ( value )
|
|
|
5680 {
|
|
|
5681 case Format::eUndefined : return "Undefined";
|
|
|
5682 case Format::eR4G4UnormPack8 : return "R4G4UnormPack8";
|
|
|
5683 case Format::eR4G4B4A4UnormPack16 : return "R4G4B4A4UnormPack16";
|
|
|
5684 case Format::eB4G4R4A4UnormPack16 : return "B4G4R4A4UnormPack16";
|
|
|
5685 case Format::eR5G6B5UnormPack16 : return "R5G6B5UnormPack16";
|
|
|
5686 case Format::eB5G6R5UnormPack16 : return "B5G6R5UnormPack16";
|
|
|
5687 case Format::eR5G5B5A1UnormPack16 : return "R5G5B5A1UnormPack16";
|
|
|
5688 case Format::eB5G5R5A1UnormPack16 : return "B5G5R5A1UnormPack16";
|
|
|
5689 case Format::eA1R5G5B5UnormPack16 : return "A1R5G5B5UnormPack16";
|
|
|
5690 case Format::eR8Unorm : return "R8Unorm";
|
|
|
5691 case Format::eR8Snorm : return "R8Snorm";
|
|
|
5692 case Format::eR8Uscaled : return "R8Uscaled";
|
|
|
5693 case Format::eR8Sscaled : return "R8Sscaled";
|
|
|
5694 case Format::eR8Uint : return "R8Uint";
|
|
|
5695 case Format::eR8Sint : return "R8Sint";
|
|
|
5696 case Format::eR8Srgb : return "R8Srgb";
|
|
|
5697 case Format::eR8G8Unorm : return "R8G8Unorm";
|
|
|
5698 case Format::eR8G8Snorm : return "R8G8Snorm";
|
|
|
5699 case Format::eR8G8Uscaled : return "R8G8Uscaled";
|
|
|
5700 case Format::eR8G8Sscaled : return "R8G8Sscaled";
|
|
|
5701 case Format::eR8G8Uint : return "R8G8Uint";
|
|
|
5702 case Format::eR8G8Sint : return "R8G8Sint";
|
|
|
5703 case Format::eR8G8Srgb : return "R8G8Srgb";
|
|
|
5704 case Format::eR8G8B8Unorm : return "R8G8B8Unorm";
|
|
|
5705 case Format::eR8G8B8Snorm : return "R8G8B8Snorm";
|
|
|
5706 case Format::eR8G8B8Uscaled : return "R8G8B8Uscaled";
|
|
|
5707 case Format::eR8G8B8Sscaled : return "R8G8B8Sscaled";
|
|
|
5708 case Format::eR8G8B8Uint : return "R8G8B8Uint";
|
|
|
5709 case Format::eR8G8B8Sint : return "R8G8B8Sint";
|
|
|
5710 case Format::eR8G8B8Srgb : return "R8G8B8Srgb";
|
|
|
5711 case Format::eB8G8R8Unorm : return "B8G8R8Unorm";
|
|
|
5712 case Format::eB8G8R8Snorm : return "B8G8R8Snorm";
|
|
|
5713 case Format::eB8G8R8Uscaled : return "B8G8R8Uscaled";
|
|
|
5714 case Format::eB8G8R8Sscaled : return "B8G8R8Sscaled";
|
|
|
5715 case Format::eB8G8R8Uint : return "B8G8R8Uint";
|
|
|
5716 case Format::eB8G8R8Sint : return "B8G8R8Sint";
|
|
|
5717 case Format::eB8G8R8Srgb : return "B8G8R8Srgb";
|
|
|
5718 case Format::eR8G8B8A8Unorm : return "R8G8B8A8Unorm";
|
|
|
5719 case Format::eR8G8B8A8Snorm : return "R8G8B8A8Snorm";
|
|
|
5720 case Format::eR8G8B8A8Uscaled : return "R8G8B8A8Uscaled";
|
|
|
5721 case Format::eR8G8B8A8Sscaled : return "R8G8B8A8Sscaled";
|
|
|
5722 case Format::eR8G8B8A8Uint : return "R8G8B8A8Uint";
|
|
|
5723 case Format::eR8G8B8A8Sint : return "R8G8B8A8Sint";
|
|
|
5724 case Format::eR8G8B8A8Srgb : return "R8G8B8A8Srgb";
|
|
|
5725 case Format::eB8G8R8A8Unorm : return "B8G8R8A8Unorm";
|
|
|
5726 case Format::eB8G8R8A8Snorm : return "B8G8R8A8Snorm";
|
|
|
5727 case Format::eB8G8R8A8Uscaled : return "B8G8R8A8Uscaled";
|
|
|
5728 case Format::eB8G8R8A8Sscaled : return "B8G8R8A8Sscaled";
|
|
|
5729 case Format::eB8G8R8A8Uint : return "B8G8R8A8Uint";
|
|
|
5730 case Format::eB8G8R8A8Sint : return "B8G8R8A8Sint";
|
|
|
5731 case Format::eB8G8R8A8Srgb : return "B8G8R8A8Srgb";
|
|
|
5732 case Format::eA8B8G8R8UnormPack32 : return "A8B8G8R8UnormPack32";
|
|
|
5733 case Format::eA8B8G8R8SnormPack32 : return "A8B8G8R8SnormPack32";
|
|
|
5734 case Format::eA8B8G8R8UscaledPack32 : return "A8B8G8R8UscaledPack32";
|
|
|
5735 case Format::eA8B8G8R8SscaledPack32 : return "A8B8G8R8SscaledPack32";
|
|
|
5736 case Format::eA8B8G8R8UintPack32 : return "A8B8G8R8UintPack32";
|
|
|
5737 case Format::eA8B8G8R8SintPack32 : return "A8B8G8R8SintPack32";
|
|
|
5738 case Format::eA8B8G8R8SrgbPack32 : return "A8B8G8R8SrgbPack32";
|
|
|
5739 case Format::eA2R10G10B10UnormPack32 : return "A2R10G10B10UnormPack32";
|
|
|
5740 case Format::eA2R10G10B10SnormPack32 : return "A2R10G10B10SnormPack32";
|
|
|
5741 case Format::eA2R10G10B10UscaledPack32 : return "A2R10G10B10UscaledPack32";
|
|
|
5742 case Format::eA2R10G10B10SscaledPack32 : return "A2R10G10B10SscaledPack32";
|
|
|
5743 case Format::eA2R10G10B10UintPack32 : return "A2R10G10B10UintPack32";
|
|
|
5744 case Format::eA2R10G10B10SintPack32 : return "A2R10G10B10SintPack32";
|
|
|
5745 case Format::eA2B10G10R10UnormPack32 : return "A2B10G10R10UnormPack32";
|
|
|
5746 case Format::eA2B10G10R10SnormPack32 : return "A2B10G10R10SnormPack32";
|
|
|
5747 case Format::eA2B10G10R10UscaledPack32 : return "A2B10G10R10UscaledPack32";
|
|
|
5748 case Format::eA2B10G10R10SscaledPack32 : return "A2B10G10R10SscaledPack32";
|
|
|
5749 case Format::eA2B10G10R10UintPack32 : return "A2B10G10R10UintPack32";
|
|
|
5750 case Format::eA2B10G10R10SintPack32 : return "A2B10G10R10SintPack32";
|
|
|
5751 case Format::eR16Unorm : return "R16Unorm";
|
|
|
5752 case Format::eR16Snorm : return "R16Snorm";
|
|
|
5753 case Format::eR16Uscaled : return "R16Uscaled";
|
|
|
5754 case Format::eR16Sscaled : return "R16Sscaled";
|
|
|
5755 case Format::eR16Uint : return "R16Uint";
|
|
|
5756 case Format::eR16Sint : return "R16Sint";
|
|
|
5757 case Format::eR16Sfloat : return "R16Sfloat";
|
|
|
5758 case Format::eR16G16Unorm : return "R16G16Unorm";
|
|
|
5759 case Format::eR16G16Snorm : return "R16G16Snorm";
|
|
|
5760 case Format::eR16G16Uscaled : return "R16G16Uscaled";
|
|
|
5761 case Format::eR16G16Sscaled : return "R16G16Sscaled";
|
|
|
5762 case Format::eR16G16Uint : return "R16G16Uint";
|
|
|
5763 case Format::eR16G16Sint : return "R16G16Sint";
|
|
|
5764 case Format::eR16G16Sfloat : return "R16G16Sfloat";
|
|
|
5765 case Format::eR16G16B16Unorm : return "R16G16B16Unorm";
|
|
|
5766 case Format::eR16G16B16Snorm : return "R16G16B16Snorm";
|
|
|
5767 case Format::eR16G16B16Uscaled : return "R16G16B16Uscaled";
|
|
|
5768 case Format::eR16G16B16Sscaled : return "R16G16B16Sscaled";
|
|
|
5769 case Format::eR16G16B16Uint : return "R16G16B16Uint";
|
|
|
5770 case Format::eR16G16B16Sint : return "R16G16B16Sint";
|
|
|
5771 case Format::eR16G16B16Sfloat : return "R16G16B16Sfloat";
|
|
|
5772 case Format::eR16G16B16A16Unorm : return "R16G16B16A16Unorm";
|
|
|
5773 case Format::eR16G16B16A16Snorm : return "R16G16B16A16Snorm";
|
|
|
5774 case Format::eR16G16B16A16Uscaled : return "R16G16B16A16Uscaled";
|
|
|
5775 case Format::eR16G16B16A16Sscaled : return "R16G16B16A16Sscaled";
|
|
|
5776 case Format::eR16G16B16A16Uint : return "R16G16B16A16Uint";
|
|
|
5777 case Format::eR16G16B16A16Sint : return "R16G16B16A16Sint";
|
|
|
5778 case Format::eR16G16B16A16Sfloat : return "R16G16B16A16Sfloat";
|
|
|
5779 case Format::eR32Uint : return "R32Uint";
|
|
|
5780 case Format::eR32Sint : return "R32Sint";
|
|
|
5781 case Format::eR32Sfloat : return "R32Sfloat";
|
|
|
5782 case Format::eR32G32Uint : return "R32G32Uint";
|
|
|
5783 case Format::eR32G32Sint : return "R32G32Sint";
|
|
|
5784 case Format::eR32G32Sfloat : return "R32G32Sfloat";
|
|
|
5785 case Format::eR32G32B32Uint : return "R32G32B32Uint";
|
|
|
5786 case Format::eR32G32B32Sint : return "R32G32B32Sint";
|
|
|
5787 case Format::eR32G32B32Sfloat : return "R32G32B32Sfloat";
|
|
|
5788 case Format::eR32G32B32A32Uint : return "R32G32B32A32Uint";
|
|
|
5789 case Format::eR32G32B32A32Sint : return "R32G32B32A32Sint";
|
|
|
5790 case Format::eR32G32B32A32Sfloat : return "R32G32B32A32Sfloat";
|
|
|
5791 case Format::eR64Uint : return "R64Uint";
|
|
|
5792 case Format::eR64Sint : return "R64Sint";
|
|
|
5793 case Format::eR64Sfloat : return "R64Sfloat";
|
|
|
5794 case Format::eR64G64Uint : return "R64G64Uint";
|
|
|
5795 case Format::eR64G64Sint : return "R64G64Sint";
|
|
|
5796 case Format::eR64G64Sfloat : return "R64G64Sfloat";
|
|
|
5797 case Format::eR64G64B64Uint : return "R64G64B64Uint";
|
|
|
5798 case Format::eR64G64B64Sint : return "R64G64B64Sint";
|
|
|
5799 case Format::eR64G64B64Sfloat : return "R64G64B64Sfloat";
|
|
|
5800 case Format::eR64G64B64A64Uint : return "R64G64B64A64Uint";
|
|
|
5801 case Format::eR64G64B64A64Sint : return "R64G64B64A64Sint";
|
|
|
5802 case Format::eR64G64B64A64Sfloat : return "R64G64B64A64Sfloat";
|
|
|
5803 case Format::eB10G11R11UfloatPack32 : return "B10G11R11UfloatPack32";
|
|
|
5804 case Format::eE5B9G9R9UfloatPack32 : return "E5B9G9R9UfloatPack32";
|
|
|
5805 case Format::eD16Unorm : return "D16Unorm";
|
|
|
5806 case Format::eX8D24UnormPack32 : return "X8D24UnormPack32";
|
|
|
5807 case Format::eD32Sfloat : return "D32Sfloat";
|
|
|
5808 case Format::eS8Uint : return "S8Uint";
|
|
|
5809 case Format::eD16UnormS8Uint : return "D16UnormS8Uint";
|
|
|
5810 case Format::eD24UnormS8Uint : return "D24UnormS8Uint";
|
|
|
5811 case Format::eD32SfloatS8Uint : return "D32SfloatS8Uint";
|
|
|
5812 case Format::eBc1RgbUnormBlock : return "Bc1RgbUnormBlock";
|
|
|
5813 case Format::eBc1RgbSrgbBlock : return "Bc1RgbSrgbBlock";
|
|
|
5814 case Format::eBc1RgbaUnormBlock : return "Bc1RgbaUnormBlock";
|
|
|
5815 case Format::eBc1RgbaSrgbBlock : return "Bc1RgbaSrgbBlock";
|
|
|
5816 case Format::eBc2UnormBlock : return "Bc2UnormBlock";
|
|
|
5817 case Format::eBc2SrgbBlock : return "Bc2SrgbBlock";
|
|
|
5818 case Format::eBc3UnormBlock : return "Bc3UnormBlock";
|
|
|
5819 case Format::eBc3SrgbBlock : return "Bc3SrgbBlock";
|
|
|
5820 case Format::eBc4UnormBlock : return "Bc4UnormBlock";
|
|
|
5821 case Format::eBc4SnormBlock : return "Bc4SnormBlock";
|
|
|
5822 case Format::eBc5UnormBlock : return "Bc5UnormBlock";
|
|
|
5823 case Format::eBc5SnormBlock : return "Bc5SnormBlock";
|
|
|
5824 case Format::eBc6HUfloatBlock : return "Bc6HUfloatBlock";
|
|
|
5825 case Format::eBc6HSfloatBlock : return "Bc6HSfloatBlock";
|
|
|
5826 case Format::eBc7UnormBlock : return "Bc7UnormBlock";
|
|
|
5827 case Format::eBc7SrgbBlock : return "Bc7SrgbBlock";
|
|
|
5828 case Format::eEtc2R8G8B8UnormBlock : return "Etc2R8G8B8UnormBlock";
|
|
|
5829 case Format::eEtc2R8G8B8SrgbBlock : return "Etc2R8G8B8SrgbBlock";
|
|
|
5830 case Format::eEtc2R8G8B8A1UnormBlock : return "Etc2R8G8B8A1UnormBlock";
|
|
|
5831 case Format::eEtc2R8G8B8A1SrgbBlock : return "Etc2R8G8B8A1SrgbBlock";
|
|
|
5832 case Format::eEtc2R8G8B8A8UnormBlock : return "Etc2R8G8B8A8UnormBlock";
|
|
|
5833 case Format::eEtc2R8G8B8A8SrgbBlock : return "Etc2R8G8B8A8SrgbBlock";
|
|
|
5834 case Format::eEacR11UnormBlock : return "EacR11UnormBlock";
|
|
|
5835 case Format::eEacR11SnormBlock : return "EacR11SnormBlock";
|
|
|
5836 case Format::eEacR11G11UnormBlock : return "EacR11G11UnormBlock";
|
|
|
5837 case Format::eEacR11G11SnormBlock : return "EacR11G11SnormBlock";
|
|
|
5838 case Format::eAstc4x4UnormBlock : return "Astc4x4UnormBlock";
|
|
|
5839 case Format::eAstc4x4SrgbBlock : return "Astc4x4SrgbBlock";
|
|
|
5840 case Format::eAstc5x4UnormBlock : return "Astc5x4UnormBlock";
|
|
|
5841 case Format::eAstc5x4SrgbBlock : return "Astc5x4SrgbBlock";
|
|
|
5842 case Format::eAstc5x5UnormBlock : return "Astc5x5UnormBlock";
|
|
|
5843 case Format::eAstc5x5SrgbBlock : return "Astc5x5SrgbBlock";
|
|
|
5844 case Format::eAstc6x5UnormBlock : return "Astc6x5UnormBlock";
|
|
|
5845 case Format::eAstc6x5SrgbBlock : return "Astc6x5SrgbBlock";
|
|
|
5846 case Format::eAstc6x6UnormBlock : return "Astc6x6UnormBlock";
|
|
|
5847 case Format::eAstc6x6SrgbBlock : return "Astc6x6SrgbBlock";
|
|
|
5848 case Format::eAstc8x5UnormBlock : return "Astc8x5UnormBlock";
|
|
|
5849 case Format::eAstc8x5SrgbBlock : return "Astc8x5SrgbBlock";
|
|
|
5850 case Format::eAstc8x6UnormBlock : return "Astc8x6UnormBlock";
|
|
|
5851 case Format::eAstc8x6SrgbBlock : return "Astc8x6SrgbBlock";
|
|
|
5852 case Format::eAstc8x8UnormBlock : return "Astc8x8UnormBlock";
|
|
|
5853 case Format::eAstc8x8SrgbBlock : return "Astc8x8SrgbBlock";
|
|
|
5854 case Format::eAstc10x5UnormBlock : return "Astc10x5UnormBlock";
|
|
|
5855 case Format::eAstc10x5SrgbBlock : return "Astc10x5SrgbBlock";
|
|
|
5856 case Format::eAstc10x6UnormBlock : return "Astc10x6UnormBlock";
|
|
|
5857 case Format::eAstc10x6SrgbBlock : return "Astc10x6SrgbBlock";
|
|
|
5858 case Format::eAstc10x8UnormBlock : return "Astc10x8UnormBlock";
|
|
|
5859 case Format::eAstc10x8SrgbBlock : return "Astc10x8SrgbBlock";
|
|
|
5860 case Format::eAstc10x10UnormBlock : return "Astc10x10UnormBlock";
|
|
|
5861 case Format::eAstc10x10SrgbBlock : return "Astc10x10SrgbBlock";
|
|
|
5862 case Format::eAstc12x10UnormBlock : return "Astc12x10UnormBlock";
|
|
|
5863 case Format::eAstc12x10SrgbBlock : return "Astc12x10SrgbBlock";
|
|
|
5864 case Format::eAstc12x12UnormBlock : return "Astc12x12UnormBlock";
|
|
|
5865 case Format::eAstc12x12SrgbBlock : return "Astc12x12SrgbBlock";
|
|
|
5866 case Format::eG8B8G8R8422Unorm : return "G8B8G8R8422Unorm";
|
|
|
5867 case Format::eB8G8R8G8422Unorm : return "B8G8R8G8422Unorm";
|
|
|
5868 case Format::eG8B8R83Plane420Unorm : return "G8B8R83Plane420Unorm";
|
|
|
5869 case Format::eG8B8R82Plane420Unorm : return "G8B8R82Plane420Unorm";
|
|
|
5870 case Format::eG8B8R83Plane422Unorm : return "G8B8R83Plane422Unorm";
|
|
|
5871 case Format::eG8B8R82Plane422Unorm : return "G8B8R82Plane422Unorm";
|
|
|
5872 case Format::eG8B8R83Plane444Unorm : return "G8B8R83Plane444Unorm";
|
|
|
5873 case Format::eR10X6UnormPack16 : return "R10X6UnormPack16";
|
|
|
5874 case Format::eR10X6G10X6Unorm2Pack16 : return "R10X6G10X6Unorm2Pack16";
|
|
|
5875 case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16 : return "R10X6G10X6B10X6A10X6Unorm4Pack16";
|
|
|
5876 case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16 : return "G10X6B10X6G10X6R10X6422Unorm4Pack16";
|
|
|
5877 case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16 : return "B10X6G10X6R10X6G10X6422Unorm4Pack16";
|
|
|
5878 case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16 : return "G10X6B10X6R10X63Plane420Unorm3Pack16";
|
|
|
5879 case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16 : return "G10X6B10X6R10X62Plane420Unorm3Pack16";
|
|
|
5880 case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16 : return "G10X6B10X6R10X63Plane422Unorm3Pack16";
|
|
|
5881 case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16 : return "G10X6B10X6R10X62Plane422Unorm3Pack16";
|
|
|
5882 case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16 : return "G10X6B10X6R10X63Plane444Unorm3Pack16";
|
|
|
5883 case Format::eR12X4UnormPack16 : return "R12X4UnormPack16";
|
|
|
5884 case Format::eR12X4G12X4Unorm2Pack16 : return "R12X4G12X4Unorm2Pack16";
|
|
|
5885 case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16 : return "R12X4G12X4B12X4A12X4Unorm4Pack16";
|
|
|
5886 case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16 : return "G12X4B12X4G12X4R12X4422Unorm4Pack16";
|
|
|
5887 case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16 : return "B12X4G12X4R12X4G12X4422Unorm4Pack16";
|
|
|
5888 case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16 : return "G12X4B12X4R12X43Plane420Unorm3Pack16";
|
|
|
5889 case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16 : return "G12X4B12X4R12X42Plane420Unorm3Pack16";
|
|
|
5890 case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16 : return "G12X4B12X4R12X43Plane422Unorm3Pack16";
|
|
|
5891 case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16 : return "G12X4B12X4R12X42Plane422Unorm3Pack16";
|
|
|
5892 case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16 : return "G12X4B12X4R12X43Plane444Unorm3Pack16";
|
|
|
5893 case Format::eG16B16G16R16422Unorm : return "G16B16G16R16422Unorm";
|
|
|
5894 case Format::eB16G16R16G16422Unorm : return "B16G16R16G16422Unorm";
|
|
|
5895 case Format::eG16B16R163Plane420Unorm : return "G16B16R163Plane420Unorm";
|
|
|
5896 case Format::eG16B16R162Plane420Unorm : return "G16B16R162Plane420Unorm";
|
|
|
5897 case Format::eG16B16R163Plane422Unorm : return "G16B16R163Plane422Unorm";
|
|
|
5898 case Format::eG16B16R162Plane422Unorm : return "G16B16R162Plane422Unorm";
|
|
|
5899 case Format::eG16B16R163Plane444Unorm : return "G16B16R163Plane444Unorm";
|
|
|
5900 case Format::eG8B8R82Plane444Unorm : return "G8B8R82Plane444Unorm";
|
|
|
5901 case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16 : return "G10X6B10X6R10X62Plane444Unorm3Pack16";
|
|
|
5902 case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16 : return "G12X4B12X4R12X42Plane444Unorm3Pack16";
|
|
|
5903 case Format::eG16B16R162Plane444Unorm : return "G16B16R162Plane444Unorm";
|
|
|
5904 case Format::eA4R4G4B4UnormPack16 : return "A4R4G4B4UnormPack16";
|
|
|
5905 case Format::eA4B4G4R4UnormPack16 : return "A4B4G4R4UnormPack16";
|
|
|
5906 case Format::eAstc4x4SfloatBlock : return "Astc4x4SfloatBlock";
|
|
|
5907 case Format::eAstc5x4SfloatBlock : return "Astc5x4SfloatBlock";
|
|
|
5908 case Format::eAstc5x5SfloatBlock : return "Astc5x5SfloatBlock";
|
|
|
5909 case Format::eAstc6x5SfloatBlock : return "Astc6x5SfloatBlock";
|
|
|
5910 case Format::eAstc6x6SfloatBlock : return "Astc6x6SfloatBlock";
|
|
|
5911 case Format::eAstc8x5SfloatBlock : return "Astc8x5SfloatBlock";
|
|
|
5912 case Format::eAstc8x6SfloatBlock : return "Astc8x6SfloatBlock";
|
|
|
5913 case Format::eAstc8x8SfloatBlock : return "Astc8x8SfloatBlock";
|
|
|
5914 case Format::eAstc10x5SfloatBlock : return "Astc10x5SfloatBlock";
|
|
|
5915 case Format::eAstc10x6SfloatBlock : return "Astc10x6SfloatBlock";
|
|
|
5916 case Format::eAstc10x8SfloatBlock : return "Astc10x8SfloatBlock";
|
|
|
5917 case Format::eAstc10x10SfloatBlock : return "Astc10x10SfloatBlock";
|
|
|
5918 case Format::eAstc12x10SfloatBlock : return "Astc12x10SfloatBlock";
|
|
|
5919 case Format::eAstc12x12SfloatBlock : return "Astc12x12SfloatBlock";
|
|
|
5920 case Format::eA1B5G5R5UnormPack16 : return "A1B5G5R5UnormPack16";
|
|
|
5921 case Format::eA8Unorm : return "A8Unorm";
|
|
|
5922 case Format::ePvrtc12BppUnormBlockIMG : return "Pvrtc12BppUnormBlockIMG";
|
|
|
5923 case Format::ePvrtc14BppUnormBlockIMG : return "Pvrtc14BppUnormBlockIMG";
|
|
|
5924 case Format::ePvrtc22BppUnormBlockIMG : return "Pvrtc22BppUnormBlockIMG";
|
|
|
5925 case Format::ePvrtc24BppUnormBlockIMG : return "Pvrtc24BppUnormBlockIMG";
|
|
|
5926 case Format::ePvrtc12BppSrgbBlockIMG : return "Pvrtc12BppSrgbBlockIMG";
|
|
|
5927 case Format::ePvrtc14BppSrgbBlockIMG : return "Pvrtc14BppSrgbBlockIMG";
|
|
|
5928 case Format::ePvrtc22BppSrgbBlockIMG : return "Pvrtc22BppSrgbBlockIMG";
|
|
|
5929 case Format::ePvrtc24BppSrgbBlockIMG : return "Pvrtc24BppSrgbBlockIMG";
|
|
|
5930 case Format::eR8BoolARM : return "R8BoolARM";
|
|
|
5931 case Format::eR16G16Sfixed5NV : return "R16G16Sfixed5NV";
|
|
|
5932 case Format::eR10X6UintPack16ARM : return "R10X6UintPack16ARM";
|
|
|
5933 case Format::eR10X6G10X6Uint2Pack16ARM : return "R10X6G10X6Uint2Pack16ARM";
|
|
|
5934 case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM : return "R10X6G10X6B10X6A10X6Uint4Pack16ARM";
|
|
|
5935 case Format::eR12X4UintPack16ARM : return "R12X4UintPack16ARM";
|
|
|
5936 case Format::eR12X4G12X4Uint2Pack16ARM : return "R12X4G12X4Uint2Pack16ARM";
|
|
|
5937 case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM : return "R12X4G12X4B12X4A12X4Uint4Pack16ARM";
|
|
|
5938 case Format::eR14X2UintPack16ARM : return "R14X2UintPack16ARM";
|
|
|
5939 case Format::eR14X2G14X2Uint2Pack16ARM : return "R14X2G14X2Uint2Pack16ARM";
|
|
|
5940 case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM : return "R14X2G14X2B14X2A14X2Uint4Pack16ARM";
|
|
|
5941 case Format::eR14X2UnormPack16ARM : return "R14X2UnormPack16ARM";
|
|
|
5942 case Format::eR14X2G14X2Unorm2Pack16ARM : return "R14X2G14X2Unorm2Pack16ARM";
|
|
|
5943 case Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM : return "R14X2G14X2B14X2A14X2Unorm4Pack16ARM";
|
|
|
5944 case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: return "G14X2B14X2R14X22Plane420Unorm3Pack16ARM";
|
|
|
5945 case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: return "G14X2B14X2R14X22Plane422Unorm3Pack16ARM";
|
|
|
5946 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
5947 }
|
|
|
5948 }
|
|
|
5949
|
|
|
5950 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FormatFeatureFlagBits value )
|
|
|
5951 {
|
|
|
5952 switch ( value )
|
|
|
5953 {
|
|
|
5954 case FormatFeatureFlagBits::eSampledImage : return "SampledImage";
|
|
|
5955 case FormatFeatureFlagBits::eStorageImage : return "StorageImage";
|
|
|
5956 case FormatFeatureFlagBits::eStorageImageAtomic : return "StorageImageAtomic";
|
|
|
5957 case FormatFeatureFlagBits::eUniformTexelBuffer : return "UniformTexelBuffer";
|
|
|
5958 case FormatFeatureFlagBits::eStorageTexelBuffer : return "StorageTexelBuffer";
|
|
|
5959 case FormatFeatureFlagBits::eStorageTexelBufferAtomic : return "StorageTexelBufferAtomic";
|
|
|
5960 case FormatFeatureFlagBits::eVertexBuffer : return "VertexBuffer";
|
|
|
5961 case FormatFeatureFlagBits::eColorAttachment : return "ColorAttachment";
|
|
|
5962 case FormatFeatureFlagBits::eColorAttachmentBlend : return "ColorAttachmentBlend";
|
|
|
5963 case FormatFeatureFlagBits::eDepthStencilAttachment : return "DepthStencilAttachment";
|
|
|
5964 case FormatFeatureFlagBits::eBlitSrc : return "BlitSrc";
|
|
|
5965 case FormatFeatureFlagBits::eBlitDst : return "BlitDst";
|
|
|
5966 case FormatFeatureFlagBits::eSampledImageFilterLinear : return "SampledImageFilterLinear";
|
|
|
5967 case FormatFeatureFlagBits::eTransferSrc : return "TransferSrc";
|
|
|
5968 case FormatFeatureFlagBits::eTransferDst : return "TransferDst";
|
|
|
5969 case FormatFeatureFlagBits::eMidpointChromaSamples : return "MidpointChromaSamples";
|
|
|
5970 case FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter : return "SampledImageYcbcrConversionLinearFilter";
|
|
|
5971 case FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter: return "SampledImageYcbcrConversionSeparateReconstructionFilter";
|
|
|
5972 case FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit: return "SampledImageYcbcrConversionChromaReconstructionExplicit";
|
|
|
5973 case FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable:
|
|
|
5974 return "SampledImageYcbcrConversionChromaReconstructionExplicitForceable";
|
|
|
5975 case FormatFeatureFlagBits::eDisjoint : return "Disjoint";
|
|
|
5976 case FormatFeatureFlagBits::eCositedChromaSamples : return "CositedChromaSamples";
|
|
|
5977 case FormatFeatureFlagBits::eSampledImageFilterMinmax : return "SampledImageFilterMinmax";
|
|
|
5978 case FormatFeatureFlagBits::eVideoDecodeOutputKHR : return "VideoDecodeOutputKHR";
|
|
|
5979 case FormatFeatureFlagBits::eVideoDecodeDpbKHR : return "VideoDecodeDpbKHR";
|
|
|
5980 case FormatFeatureFlagBits::eAccelerationStructureVertexBufferKHR: return "AccelerationStructureVertexBufferKHR";
|
|
|
5981 case FormatFeatureFlagBits::eSampledImageFilterCubicEXT : return "SampledImageFilterCubicEXT";
|
|
|
5982 case FormatFeatureFlagBits::eFragmentDensityMapEXT : return "FragmentDensityMapEXT";
|
|
|
5983 case FormatFeatureFlagBits::eFragmentShadingRateAttachmentKHR : return "FragmentShadingRateAttachmentKHR";
|
|
|
5984 case FormatFeatureFlagBits::eVideoEncodeInputKHR : return "VideoEncodeInputKHR";
|
|
|
5985 case FormatFeatureFlagBits::eVideoEncodeDpbKHR : return "VideoEncodeDpbKHR";
|
|
|
5986 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
5987 }
|
|
|
5988 }
|
|
|
5989
|
|
|
5990 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageCreateFlagBits value )
|
|
|
5991 {
|
|
|
5992 switch ( value )
|
|
|
5993 {
|
|
|
5994 case ImageCreateFlagBits::eSparseBinding : return "SparseBinding";
|
|
|
5995 case ImageCreateFlagBits::eSparseResidency : return "SparseResidency";
|
|
|
5996 case ImageCreateFlagBits::eSparseAliased : return "SparseAliased";
|
|
|
5997 case ImageCreateFlagBits::eMutableFormat : return "MutableFormat";
|
|
|
5998 case ImageCreateFlagBits::eCubeCompatible : return "CubeCompatible";
|
|
|
5999 case ImageCreateFlagBits::eAlias : return "Alias";
|
|
|
6000 case ImageCreateFlagBits::eSplitInstanceBindRegions : return "SplitInstanceBindRegions";
|
|
|
6001 case ImageCreateFlagBits::e2DArrayCompatible : return "2DArrayCompatible";
|
|
|
6002 case ImageCreateFlagBits::eBlockTexelViewCompatible : return "BlockTexelViewCompatible";
|
|
|
6003 case ImageCreateFlagBits::eExtendedUsage : return "ExtendedUsage";
|
|
|
6004 case ImageCreateFlagBits::eProtected : return "Protected";
|
|
|
6005 case ImageCreateFlagBits::eDisjoint : return "Disjoint";
|
|
|
6006 case ImageCreateFlagBits::eCornerSampledNV : return "CornerSampledNV";
|
|
|
6007 case ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT : return "SampleLocationsCompatibleDepthEXT";
|
|
|
6008 case ImageCreateFlagBits::eSubsampledEXT : return "SubsampledEXT";
|
|
|
6009 case ImageCreateFlagBits::eDescriptorBufferCaptureReplayEXT : return "DescriptorBufferCaptureReplayEXT";
|
|
|
6010 case ImageCreateFlagBits::eMultisampledRenderToSingleSampledEXT: return "MultisampledRenderToSingleSampledEXT";
|
|
|
6011 case ImageCreateFlagBits::e2DViewCompatibleEXT : return "2DViewCompatibleEXT";
|
|
|
6012 case ImageCreateFlagBits::eVideoProfileIndependentKHR : return "VideoProfileIndependentKHR";
|
|
|
6013 case ImageCreateFlagBits::eFragmentDensityMapOffsetEXT : return "FragmentDensityMapOffsetEXT";
|
|
|
6014 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6015 }
|
|
|
6016 }
|
|
|
6017
|
|
|
6018 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageTiling value )
|
|
|
6019 {
|
|
|
6020 switch ( value )
|
|
|
6021 {
|
|
|
6022 case ImageTiling::eOptimal : return "Optimal";
|
|
|
6023 case ImageTiling::eLinear : return "Linear";
|
|
|
6024 case ImageTiling::eDrmFormatModifierEXT: return "DrmFormatModifierEXT";
|
|
|
6025 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6026 }
|
|
|
6027 }
|
|
|
6028
|
|
|
6029 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageType value )
|
|
|
6030 {
|
|
|
6031 switch ( value )
|
|
|
6032 {
|
|
|
6033 case ImageType::e1D: return "1D";
|
|
|
6034 case ImageType::e2D: return "2D";
|
|
|
6035 case ImageType::e3D: return "3D";
|
|
|
6036 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6037 }
|
|
|
6038 }
|
|
|
6039
|
|
|
6040 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageUsageFlagBits value )
|
|
|
6041 {
|
|
|
6042 switch ( value )
|
|
|
6043 {
|
|
|
6044 case ImageUsageFlagBits::eTransferSrc : return "TransferSrc";
|
|
|
6045 case ImageUsageFlagBits::eTransferDst : return "TransferDst";
|
|
|
6046 case ImageUsageFlagBits::eSampled : return "Sampled";
|
|
|
6047 case ImageUsageFlagBits::eStorage : return "Storage";
|
|
|
6048 case ImageUsageFlagBits::eColorAttachment : return "ColorAttachment";
|
|
|
6049 case ImageUsageFlagBits::eDepthStencilAttachment : return "DepthStencilAttachment";
|
|
|
6050 case ImageUsageFlagBits::eTransientAttachment : return "TransientAttachment";
|
|
|
6051 case ImageUsageFlagBits::eInputAttachment : return "InputAttachment";
|
|
|
6052 case ImageUsageFlagBits::eHostTransfer : return "HostTransfer";
|
|
|
6053 case ImageUsageFlagBits::eVideoDecodeDstKHR : return "VideoDecodeDstKHR";
|
|
|
6054 case ImageUsageFlagBits::eVideoDecodeSrcKHR : return "VideoDecodeSrcKHR";
|
|
|
6055 case ImageUsageFlagBits::eVideoDecodeDpbKHR : return "VideoDecodeDpbKHR";
|
|
|
6056 case ImageUsageFlagBits::eFragmentDensityMapEXT : return "FragmentDensityMapEXT";
|
|
|
6057 case ImageUsageFlagBits::eFragmentShadingRateAttachmentKHR : return "FragmentShadingRateAttachmentKHR";
|
|
|
6058 case ImageUsageFlagBits::eVideoEncodeDstKHR : return "VideoEncodeDstKHR";
|
|
|
6059 case ImageUsageFlagBits::eVideoEncodeSrcKHR : return "VideoEncodeSrcKHR";
|
|
|
6060 case ImageUsageFlagBits::eVideoEncodeDpbKHR : return "VideoEncodeDpbKHR";
|
|
|
6061 case ImageUsageFlagBits::eAttachmentFeedbackLoopEXT : return "AttachmentFeedbackLoopEXT";
|
|
|
6062 case ImageUsageFlagBits::eInvocationMaskHUAWEI : return "InvocationMaskHUAWEI";
|
|
|
6063 case ImageUsageFlagBits::eSampleWeightQCOM : return "SampleWeightQCOM";
|
|
|
6064 case ImageUsageFlagBits::eSampleBlockMatchQCOM : return "SampleBlockMatchQCOM";
|
|
|
6065 case ImageUsageFlagBits::eTensorAliasingARM : return "TensorAliasingARM";
|
|
|
6066 case ImageUsageFlagBits::eTileMemoryQCOM : return "TileMemoryQCOM";
|
|
|
6067 case ImageUsageFlagBits::eVideoEncodeQuantizationDeltaMapKHR: return "VideoEncodeQuantizationDeltaMapKHR";
|
|
|
6068 case ImageUsageFlagBits::eVideoEncodeEmphasisMapKHR : return "VideoEncodeEmphasisMapKHR";
|
|
|
6069 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6070 }
|
|
|
6071 }
|
|
|
6072
|
|
|
6073 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( InstanceCreateFlagBits value )
|
|
|
6074 {
|
|
|
6075 switch ( value )
|
|
|
6076 {
|
|
|
6077 case InstanceCreateFlagBits::eEnumeratePortabilityKHR: return "EnumeratePortabilityKHR";
|
|
|
6078 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6079 }
|
|
|
6080 }
|
|
|
6081
|
|
|
6082 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( InternalAllocationType value )
|
|
|
6083 {
|
|
|
6084 switch ( value )
|
|
|
6085 {
|
|
|
6086 case InternalAllocationType::eExecutable: return "Executable";
|
|
|
6087 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6088 }
|
|
|
6089 }
|
|
|
6090
|
|
|
6091 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MemoryHeapFlagBits value )
|
|
|
6092 {
|
|
|
6093 switch ( value )
|
|
|
6094 {
|
|
|
6095 case MemoryHeapFlagBits::eDeviceLocal : return "DeviceLocal";
|
|
|
6096 case MemoryHeapFlagBits::eMultiInstance : return "MultiInstance";
|
|
|
6097 case MemoryHeapFlagBits::eTileMemoryQCOM: return "TileMemoryQCOM";
|
|
|
6098 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6099 }
|
|
|
6100 }
|
|
|
6101
|
|
|
6102 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MemoryPropertyFlagBits value )
|
|
|
6103 {
|
|
|
6104 switch ( value )
|
|
|
6105 {
|
|
|
6106 case MemoryPropertyFlagBits::eDeviceLocal : return "DeviceLocal";
|
|
|
6107 case MemoryPropertyFlagBits::eHostVisible : return "HostVisible";
|
|
|
6108 case MemoryPropertyFlagBits::eHostCoherent : return "HostCoherent";
|
|
|
6109 case MemoryPropertyFlagBits::eHostCached : return "HostCached";
|
|
|
6110 case MemoryPropertyFlagBits::eLazilyAllocated : return "LazilyAllocated";
|
|
|
6111 case MemoryPropertyFlagBits::eProtected : return "Protected";
|
|
|
6112 case MemoryPropertyFlagBits::eDeviceCoherentAMD: return "DeviceCoherentAMD";
|
|
|
6113 case MemoryPropertyFlagBits::eDeviceUncachedAMD: return "DeviceUncachedAMD";
|
|
|
6114 case MemoryPropertyFlagBits::eRdmaCapableNV : return "RdmaCapableNV";
|
|
|
6115 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6116 }
|
|
|
6117 }
|
|
|
6118
|
|
|
6119 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PhysicalDeviceType value )
|
|
|
6120 {
|
|
|
6121 switch ( value )
|
|
|
6122 {
|
|
|
6123 case PhysicalDeviceType::eOther : return "Other";
|
|
|
6124 case PhysicalDeviceType::eIntegratedGpu: return "IntegratedGpu";
|
|
|
6125 case PhysicalDeviceType::eDiscreteGpu : return "DiscreteGpu";
|
|
|
6126 case PhysicalDeviceType::eVirtualGpu : return "VirtualGpu";
|
|
|
6127 case PhysicalDeviceType::eCpu : return "Cpu";
|
|
|
6128 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6129 }
|
|
|
6130 }
|
|
|
6131
|
|
|
6132 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( QueueFlagBits value )
|
|
|
6133 {
|
|
|
6134 switch ( value )
|
|
|
6135 {
|
|
|
6136 case QueueFlagBits::eGraphics : return "Graphics";
|
|
|
6137 case QueueFlagBits::eCompute : return "Compute";
|
|
|
6138 case QueueFlagBits::eTransfer : return "Transfer";
|
|
|
6139 case QueueFlagBits::eSparseBinding : return "SparseBinding";
|
|
|
6140 case QueueFlagBits::eProtected : return "Protected";
|
|
|
6141 case QueueFlagBits::eVideoDecodeKHR: return "VideoDecodeKHR";
|
|
|
6142 case QueueFlagBits::eVideoEncodeKHR: return "VideoEncodeKHR";
|
|
|
6143 case QueueFlagBits::eOpticalFlowNV : return "OpticalFlowNV";
|
|
|
6144 case QueueFlagBits::eDataGraphARM : return "DataGraphARM";
|
|
|
6145 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6146 }
|
|
|
6147 }
|
|
|
6148
|
|
|
6149 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SampleCountFlagBits value )
|
|
|
6150 {
|
|
|
6151 switch ( value )
|
|
|
6152 {
|
|
|
6153 case SampleCountFlagBits::e1 : return "1";
|
|
|
6154 case SampleCountFlagBits::e2 : return "2";
|
|
|
6155 case SampleCountFlagBits::e4 : return "4";
|
|
|
6156 case SampleCountFlagBits::e8 : return "8";
|
|
|
6157 case SampleCountFlagBits::e16: return "16";
|
|
|
6158 case SampleCountFlagBits::e32: return "32";
|
|
|
6159 case SampleCountFlagBits::e64: return "64";
|
|
|
6160 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6161 }
|
|
|
6162 }
|
|
|
6163
|
|
|
6164 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SystemAllocationScope value )
|
|
|
6165 {
|
|
|
6166 switch ( value )
|
|
|
6167 {
|
|
|
6168 case SystemAllocationScope::eCommand : return "Command";
|
|
|
6169 case SystemAllocationScope::eObject : return "Object";
|
|
|
6170 case SystemAllocationScope::eCache : return "Cache";
|
|
|
6171 case SystemAllocationScope::eDevice : return "Device";
|
|
|
6172 case SystemAllocationScope::eInstance: return "Instance";
|
|
|
6173 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6174 }
|
|
|
6175 }
|
|
|
6176
|
|
|
6177 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceCreateFlagBits )
|
|
|
6178 {
|
|
|
6179 return "(void)";
|
|
|
6180 }
|
|
|
6181
|
|
|
6182 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceQueueCreateFlagBits value )
|
|
|
6183 {
|
|
|
6184 switch ( value )
|
|
|
6185 {
|
|
|
6186 case DeviceQueueCreateFlagBits::eProtected: return "Protected";
|
|
|
6187 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6188 }
|
|
|
6189 }
|
|
|
6190
|
|
|
6191 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineStageFlagBits value )
|
|
|
6192 {
|
|
|
6193 switch ( value )
|
|
|
6194 {
|
|
|
6195 case PipelineStageFlagBits::eTopOfPipe : return "TopOfPipe";
|
|
|
6196 case PipelineStageFlagBits::eDrawIndirect : return "DrawIndirect";
|
|
|
6197 case PipelineStageFlagBits::eVertexInput : return "VertexInput";
|
|
|
6198 case PipelineStageFlagBits::eVertexShader : return "VertexShader";
|
|
|
6199 case PipelineStageFlagBits::eTessellationControlShader : return "TessellationControlShader";
|
|
|
6200 case PipelineStageFlagBits::eTessellationEvaluationShader : return "TessellationEvaluationShader";
|
|
|
6201 case PipelineStageFlagBits::eGeometryShader : return "GeometryShader";
|
|
|
6202 case PipelineStageFlagBits::eFragmentShader : return "FragmentShader";
|
|
|
6203 case PipelineStageFlagBits::eEarlyFragmentTests : return "EarlyFragmentTests";
|
|
|
6204 case PipelineStageFlagBits::eLateFragmentTests : return "LateFragmentTests";
|
|
|
6205 case PipelineStageFlagBits::eColorAttachmentOutput : return "ColorAttachmentOutput";
|
|
|
6206 case PipelineStageFlagBits::eComputeShader : return "ComputeShader";
|
|
|
6207 case PipelineStageFlagBits::eTransfer : return "Transfer";
|
|
|
6208 case PipelineStageFlagBits::eBottomOfPipe : return "BottomOfPipe";
|
|
|
6209 case PipelineStageFlagBits::eHost : return "Host";
|
|
|
6210 case PipelineStageFlagBits::eAllGraphics : return "AllGraphics";
|
|
|
6211 case PipelineStageFlagBits::eAllCommands : return "AllCommands";
|
|
|
6212 case PipelineStageFlagBits::eNone : return "None";
|
|
|
6213 case PipelineStageFlagBits::eTransformFeedbackEXT : return "TransformFeedbackEXT";
|
|
|
6214 case PipelineStageFlagBits::eConditionalRenderingEXT : return "ConditionalRenderingEXT";
|
|
|
6215 case PipelineStageFlagBits::eAccelerationStructureBuildKHR : return "AccelerationStructureBuildKHR";
|
|
|
6216 case PipelineStageFlagBits::eRayTracingShaderKHR : return "RayTracingShaderKHR";
|
|
|
6217 case PipelineStageFlagBits::eFragmentDensityProcessEXT : return "FragmentDensityProcessEXT";
|
|
|
6218 case PipelineStageFlagBits::eFragmentShadingRateAttachmentKHR: return "FragmentShadingRateAttachmentKHR";
|
|
|
6219 case PipelineStageFlagBits::eTaskShaderEXT : return "TaskShaderEXT";
|
|
|
6220 case PipelineStageFlagBits::eMeshShaderEXT : return "MeshShaderEXT";
|
|
|
6221 case PipelineStageFlagBits::eCommandPreprocessEXT : return "CommandPreprocessEXT";
|
|
|
6222 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6223 }
|
|
|
6224 }
|
|
|
6225
|
|
|
6226 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MemoryMapFlagBits value )
|
|
|
6227 {
|
|
|
6228 switch ( value )
|
|
|
6229 {
|
|
|
6230 case MemoryMapFlagBits::ePlacedEXT: return "PlacedEXT";
|
|
|
6231 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6232 }
|
|
|
6233 }
|
|
|
6234
|
|
|
6235 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageAspectFlagBits value )
|
|
|
6236 {
|
|
|
6237 switch ( value )
|
|
|
6238 {
|
|
|
6239 case ImageAspectFlagBits::eColor : return "Color";
|
|
|
6240 case ImageAspectFlagBits::eDepth : return "Depth";
|
|
|
6241 case ImageAspectFlagBits::eStencil : return "Stencil";
|
|
|
6242 case ImageAspectFlagBits::eMetadata : return "Metadata";
|
|
|
6243 case ImageAspectFlagBits::ePlane0 : return "Plane0";
|
|
|
6244 case ImageAspectFlagBits::ePlane1 : return "Plane1";
|
|
|
6245 case ImageAspectFlagBits::ePlane2 : return "Plane2";
|
|
|
6246 case ImageAspectFlagBits::eNone : return "None";
|
|
|
6247 case ImageAspectFlagBits::eMemoryPlane0EXT: return "MemoryPlane0EXT";
|
|
|
6248 case ImageAspectFlagBits::eMemoryPlane1EXT: return "MemoryPlane1EXT";
|
|
|
6249 case ImageAspectFlagBits::eMemoryPlane2EXT: return "MemoryPlane2EXT";
|
|
|
6250 case ImageAspectFlagBits::eMemoryPlane3EXT: return "MemoryPlane3EXT";
|
|
|
6251 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6252 }
|
|
|
6253 }
|
|
|
6254
|
|
|
6255 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SparseImageFormatFlagBits value )
|
|
|
6256 {
|
|
|
6257 switch ( value )
|
|
|
6258 {
|
|
|
6259 case SparseImageFormatFlagBits::eSingleMiptail : return "SingleMiptail";
|
|
|
6260 case SparseImageFormatFlagBits::eAlignedMipSize : return "AlignedMipSize";
|
|
|
6261 case SparseImageFormatFlagBits::eNonstandardBlockSize: return "NonstandardBlockSize";
|
|
|
6262 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6263 }
|
|
|
6264 }
|
|
|
6265
|
|
|
6266 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SparseMemoryBindFlagBits value )
|
|
|
6267 {
|
|
|
6268 switch ( value )
|
|
|
6269 {
|
|
|
6270 case SparseMemoryBindFlagBits::eMetadata: return "Metadata";
|
|
|
6271 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6272 }
|
|
|
6273 }
|
|
|
6274
|
|
|
6275 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FenceCreateFlagBits value )
|
|
|
6276 {
|
|
|
6277 switch ( value )
|
|
|
6278 {
|
|
|
6279 case FenceCreateFlagBits::eSignaled: return "Signaled";
|
|
|
6280 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6281 }
|
|
|
6282 }
|
|
|
6283
|
|
|
6284 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SemaphoreCreateFlagBits )
|
|
|
6285 {
|
|
|
6286 return "(void)";
|
|
|
6287 }
|
|
|
6288
|
|
|
6289 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( QueryPoolCreateFlagBits value )
|
|
|
6290 {
|
|
|
6291 switch ( value )
|
|
|
6292 {
|
|
|
6293 case QueryPoolCreateFlagBits::eResetKHR: return "ResetKHR";
|
|
|
6294 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6295 }
|
|
|
6296 }
|
|
|
6297
|
|
|
6298 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( QueryResultFlagBits value )
|
|
|
6299 {
|
|
|
6300 switch ( value )
|
|
|
6301 {
|
|
|
6302 case QueryResultFlagBits::e64 : return "64";
|
|
|
6303 case QueryResultFlagBits::eWait : return "Wait";
|
|
|
6304 case QueryResultFlagBits::eWithAvailability: return "WithAvailability";
|
|
|
6305 case QueryResultFlagBits::ePartial : return "Partial";
|
|
|
6306 case QueryResultFlagBits::eWithStatusKHR : return "WithStatusKHR";
|
|
|
6307 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6308 }
|
|
|
6309 }
|
|
|
6310
|
|
|
6311 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( QueryType value )
|
|
|
6312 {
|
|
|
6313 switch ( value )
|
|
|
6314 {
|
|
|
6315 case QueryType::eOcclusion : return "Occlusion";
|
|
|
6316 case QueryType::ePipelineStatistics : return "PipelineStatistics";
|
|
|
6317 case QueryType::eTimestamp : return "Timestamp";
|
|
|
6318 case QueryType::eResultStatusOnlyKHR : return "ResultStatusOnlyKHR";
|
|
|
6319 case QueryType::eTransformFeedbackStreamEXT : return "TransformFeedbackStreamEXT";
|
|
|
6320 case QueryType::ePerformanceQueryKHR : return "PerformanceQueryKHR";
|
|
|
6321 case QueryType::eAccelerationStructureCompactedSizeKHR : return "AccelerationStructureCompactedSizeKHR";
|
|
|
6322 case QueryType::eAccelerationStructureSerializationSizeKHR : return "AccelerationStructureSerializationSizeKHR";
|
|
|
6323 case QueryType::eAccelerationStructureCompactedSizeNV : return "AccelerationStructureCompactedSizeNV";
|
|
|
6324 case QueryType::ePerformanceQueryINTEL : return "PerformanceQueryINTEL";
|
|
|
6325 case QueryType::eVideoEncodeFeedbackKHR : return "VideoEncodeFeedbackKHR";
|
|
|
6326 case QueryType::eMeshPrimitivesGeneratedEXT : return "MeshPrimitivesGeneratedEXT";
|
|
|
6327 case QueryType::ePrimitivesGeneratedEXT : return "PrimitivesGeneratedEXT";
|
|
|
6328 case QueryType::eAccelerationStructureSerializationBottomLevelPointersKHR: return "AccelerationStructureSerializationBottomLevelPointersKHR";
|
|
|
6329 case QueryType::eAccelerationStructureSizeKHR : return "AccelerationStructureSizeKHR";
|
|
|
6330 case QueryType::eMicromapSerializationSizeEXT : return "MicromapSerializationSizeEXT";
|
|
|
6331 case QueryType::eMicromapCompactedSizeEXT : return "MicromapCompactedSizeEXT";
|
|
|
6332 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6333 }
|
|
|
6334 }
|
|
|
6335
|
|
|
6336 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BufferCreateFlagBits value )
|
|
|
6337 {
|
|
|
6338 switch ( value )
|
|
|
6339 {
|
|
|
6340 case BufferCreateFlagBits::eSparseBinding : return "SparseBinding";
|
|
|
6341 case BufferCreateFlagBits::eSparseResidency : return "SparseResidency";
|
|
|
6342 case BufferCreateFlagBits::eSparseAliased : return "SparseAliased";
|
|
|
6343 case BufferCreateFlagBits::eProtected : return "Protected";
|
|
|
6344 case BufferCreateFlagBits::eDeviceAddressCaptureReplay : return "DeviceAddressCaptureReplay";
|
|
|
6345 case BufferCreateFlagBits::eDescriptorBufferCaptureReplayEXT: return "DescriptorBufferCaptureReplayEXT";
|
|
|
6346 case BufferCreateFlagBits::eVideoProfileIndependentKHR : return "VideoProfileIndependentKHR";
|
|
|
6347 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6348 }
|
|
|
6349 }
|
|
|
6350
|
|
|
6351 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BufferUsageFlagBits value )
|
|
|
6352 {
|
|
|
6353 switch ( value )
|
|
|
6354 {
|
|
|
6355 case BufferUsageFlagBits::eTransferSrc : return "TransferSrc";
|
|
|
6356 case BufferUsageFlagBits::eTransferDst : return "TransferDst";
|
|
|
6357 case BufferUsageFlagBits::eUniformTexelBuffer : return "UniformTexelBuffer";
|
|
|
6358 case BufferUsageFlagBits::eStorageTexelBuffer : return "StorageTexelBuffer";
|
|
|
6359 case BufferUsageFlagBits::eUniformBuffer : return "UniformBuffer";
|
|
|
6360 case BufferUsageFlagBits::eStorageBuffer : return "StorageBuffer";
|
|
|
6361 case BufferUsageFlagBits::eIndexBuffer : return "IndexBuffer";
|
|
|
6362 case BufferUsageFlagBits::eVertexBuffer : return "VertexBuffer";
|
|
|
6363 case BufferUsageFlagBits::eIndirectBuffer : return "IndirectBuffer";
|
|
|
6364 case BufferUsageFlagBits::eShaderDeviceAddress : return "ShaderDeviceAddress";
|
|
|
6365 case BufferUsageFlagBits::eVideoDecodeSrcKHR : return "VideoDecodeSrcKHR";
|
|
|
6366 case BufferUsageFlagBits::eVideoDecodeDstKHR : return "VideoDecodeDstKHR";
|
|
|
6367 case BufferUsageFlagBits::eTransformFeedbackBufferEXT : return "TransformFeedbackBufferEXT";
|
|
|
6368 case BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT: return "TransformFeedbackCounterBufferEXT";
|
|
|
6369 case BufferUsageFlagBits::eConditionalRenderingEXT : return "ConditionalRenderingEXT";
|
|
|
6370 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
6371 case BufferUsageFlagBits::eExecutionGraphScratchAMDX: return "ExecutionGraphScratchAMDX";
|
|
|
6372 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
6373 case BufferUsageFlagBits::eAccelerationStructureBuildInputReadOnlyKHR: return "AccelerationStructureBuildInputReadOnlyKHR";
|
|
|
6374 case BufferUsageFlagBits::eAccelerationStructureStorageKHR : return "AccelerationStructureStorageKHR";
|
|
|
6375 case BufferUsageFlagBits::eShaderBindingTableKHR : return "ShaderBindingTableKHR";
|
|
|
6376 case BufferUsageFlagBits::eVideoEncodeDstKHR : return "VideoEncodeDstKHR";
|
|
|
6377 case BufferUsageFlagBits::eVideoEncodeSrcKHR : return "VideoEncodeSrcKHR";
|
|
|
6378 case BufferUsageFlagBits::eSamplerDescriptorBufferEXT : return "SamplerDescriptorBufferEXT";
|
|
|
6379 case BufferUsageFlagBits::eResourceDescriptorBufferEXT : return "ResourceDescriptorBufferEXT";
|
|
|
6380 case BufferUsageFlagBits::ePushDescriptorsDescriptorBufferEXT : return "PushDescriptorsDescriptorBufferEXT";
|
|
|
6381 case BufferUsageFlagBits::eMicromapBuildInputReadOnlyEXT : return "MicromapBuildInputReadOnlyEXT";
|
|
|
6382 case BufferUsageFlagBits::eMicromapStorageEXT : return "MicromapStorageEXT";
|
|
|
6383 case BufferUsageFlagBits::eTileMemoryQCOM : return "TileMemoryQCOM";
|
|
|
6384 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6385 }
|
|
|
6386 }
|
|
|
6387
|
|
|
6388 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SharingMode value )
|
|
|
6389 {
|
|
|
6390 switch ( value )
|
|
|
6391 {
|
|
|
6392 case SharingMode::eExclusive : return "Exclusive";
|
|
|
6393 case SharingMode::eConcurrent: return "Concurrent";
|
|
|
6394 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6395 }
|
|
|
6396 }
|
|
|
6397
|
|
|
6398 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageLayout value )
|
|
|
6399 {
|
|
|
6400 switch ( value )
|
|
|
6401 {
|
|
|
6402 case ImageLayout::eUndefined : return "Undefined";
|
|
|
6403 case ImageLayout::eGeneral : return "General";
|
|
|
6404 case ImageLayout::eColorAttachmentOptimal : return "ColorAttachmentOptimal";
|
|
|
6405 case ImageLayout::eDepthStencilAttachmentOptimal : return "DepthStencilAttachmentOptimal";
|
|
|
6406 case ImageLayout::eDepthStencilReadOnlyOptimal : return "DepthStencilReadOnlyOptimal";
|
|
|
6407 case ImageLayout::eShaderReadOnlyOptimal : return "ShaderReadOnlyOptimal";
|
|
|
6408 case ImageLayout::eTransferSrcOptimal : return "TransferSrcOptimal";
|
|
|
6409 case ImageLayout::eTransferDstOptimal : return "TransferDstOptimal";
|
|
|
6410 case ImageLayout::ePreinitialized : return "Preinitialized";
|
|
|
6411 case ImageLayout::eDepthReadOnlyStencilAttachmentOptimal : return "DepthReadOnlyStencilAttachmentOptimal";
|
|
|
6412 case ImageLayout::eDepthAttachmentStencilReadOnlyOptimal : return "DepthAttachmentStencilReadOnlyOptimal";
|
|
|
6413 case ImageLayout::eDepthAttachmentOptimal : return "DepthAttachmentOptimal";
|
|
|
6414 case ImageLayout::eDepthReadOnlyOptimal : return "DepthReadOnlyOptimal";
|
|
|
6415 case ImageLayout::eStencilAttachmentOptimal : return "StencilAttachmentOptimal";
|
|
|
6416 case ImageLayout::eStencilReadOnlyOptimal : return "StencilReadOnlyOptimal";
|
|
|
6417 case ImageLayout::eReadOnlyOptimal : return "ReadOnlyOptimal";
|
|
|
6418 case ImageLayout::eAttachmentOptimal : return "AttachmentOptimal";
|
|
|
6419 case ImageLayout::eRenderingLocalRead : return "RenderingLocalRead";
|
|
|
6420 case ImageLayout::ePresentSrcKHR : return "PresentSrcKHR";
|
|
|
6421 case ImageLayout::eVideoDecodeDstKHR : return "VideoDecodeDstKHR";
|
|
|
6422 case ImageLayout::eVideoDecodeSrcKHR : return "VideoDecodeSrcKHR";
|
|
|
6423 case ImageLayout::eVideoDecodeDpbKHR : return "VideoDecodeDpbKHR";
|
|
|
6424 case ImageLayout::eSharedPresentKHR : return "SharedPresentKHR";
|
|
|
6425 case ImageLayout::eFragmentDensityMapOptimalEXT : return "FragmentDensityMapOptimalEXT";
|
|
|
6426 case ImageLayout::eFragmentShadingRateAttachmentOptimalKHR: return "FragmentShadingRateAttachmentOptimalKHR";
|
|
|
6427 case ImageLayout::eVideoEncodeDstKHR : return "VideoEncodeDstKHR";
|
|
|
6428 case ImageLayout::eVideoEncodeSrcKHR : return "VideoEncodeSrcKHR";
|
|
|
6429 case ImageLayout::eVideoEncodeDpbKHR : return "VideoEncodeDpbKHR";
|
|
|
6430 case ImageLayout::eAttachmentFeedbackLoopOptimalEXT : return "AttachmentFeedbackLoopOptimalEXT";
|
|
|
6431 case ImageLayout::eTensorAliasingARM : return "TensorAliasingARM";
|
|
|
6432 case ImageLayout::eVideoEncodeQuantizationMapKHR : return "VideoEncodeQuantizationMapKHR";
|
|
|
6433 case ImageLayout::eZeroInitializedEXT : return "ZeroInitializedEXT";
|
|
|
6434 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6435 }
|
|
|
6436 }
|
|
|
6437
|
|
|
6438 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ComponentSwizzle value )
|
|
|
6439 {
|
|
|
6440 switch ( value )
|
|
|
6441 {
|
|
|
6442 case ComponentSwizzle::eIdentity: return "Identity";
|
|
|
6443 case ComponentSwizzle::eZero : return "Zero";
|
|
|
6444 case ComponentSwizzle::eOne : return "One";
|
|
|
6445 case ComponentSwizzle::eR : return "R";
|
|
|
6446 case ComponentSwizzle::eG : return "G";
|
|
|
6447 case ComponentSwizzle::eB : return "B";
|
|
|
6448 case ComponentSwizzle::eA : return "A";
|
|
|
6449 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6450 }
|
|
|
6451 }
|
|
|
6452
|
|
|
6453 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageViewCreateFlagBits value )
|
|
|
6454 {
|
|
|
6455 switch ( value )
|
|
|
6456 {
|
|
|
6457 case ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT : return "FragmentDensityMapDynamicEXT";
|
|
|
6458 case ImageViewCreateFlagBits::eDescriptorBufferCaptureReplayEXT: return "DescriptorBufferCaptureReplayEXT";
|
|
|
6459 case ImageViewCreateFlagBits::eFragmentDensityMapDeferredEXT : return "FragmentDensityMapDeferredEXT";
|
|
|
6460 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6461 }
|
|
|
6462 }
|
|
|
6463
|
|
|
6464 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageViewType value )
|
|
|
6465 {
|
|
|
6466 switch ( value )
|
|
|
6467 {
|
|
|
6468 case ImageViewType::e1D : return "1D";
|
|
|
6469 case ImageViewType::e2D : return "2D";
|
|
|
6470 case ImageViewType::e3D : return "3D";
|
|
|
6471 case ImageViewType::eCube : return "Cube";
|
|
|
6472 case ImageViewType::e1DArray : return "1DArray";
|
|
|
6473 case ImageViewType::e2DArray : return "2DArray";
|
|
|
6474 case ImageViewType::eCubeArray: return "CubeArray";
|
|
|
6475 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6476 }
|
|
|
6477 }
|
|
|
6478
|
|
|
6479 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccessFlagBits value )
|
|
|
6480 {
|
|
|
6481 switch ( value )
|
|
|
6482 {
|
|
|
6483 case AccessFlagBits::eIndirectCommandRead : return "IndirectCommandRead";
|
|
|
6484 case AccessFlagBits::eIndexRead : return "IndexRead";
|
|
|
6485 case AccessFlagBits::eVertexAttributeRead : return "VertexAttributeRead";
|
|
|
6486 case AccessFlagBits::eUniformRead : return "UniformRead";
|
|
|
6487 case AccessFlagBits::eInputAttachmentRead : return "InputAttachmentRead";
|
|
|
6488 case AccessFlagBits::eShaderRead : return "ShaderRead";
|
|
|
6489 case AccessFlagBits::eShaderWrite : return "ShaderWrite";
|
|
|
6490 case AccessFlagBits::eColorAttachmentRead : return "ColorAttachmentRead";
|
|
|
6491 case AccessFlagBits::eColorAttachmentWrite : return "ColorAttachmentWrite";
|
|
|
6492 case AccessFlagBits::eDepthStencilAttachmentRead : return "DepthStencilAttachmentRead";
|
|
|
6493 case AccessFlagBits::eDepthStencilAttachmentWrite : return "DepthStencilAttachmentWrite";
|
|
|
6494 case AccessFlagBits::eTransferRead : return "TransferRead";
|
|
|
6495 case AccessFlagBits::eTransferWrite : return "TransferWrite";
|
|
|
6496 case AccessFlagBits::eHostRead : return "HostRead";
|
|
|
6497 case AccessFlagBits::eHostWrite : return "HostWrite";
|
|
|
6498 case AccessFlagBits::eMemoryRead : return "MemoryRead";
|
|
|
6499 case AccessFlagBits::eMemoryWrite : return "MemoryWrite";
|
|
|
6500 case AccessFlagBits::eNone : return "None";
|
|
|
6501 case AccessFlagBits::eTransformFeedbackWriteEXT : return "TransformFeedbackWriteEXT";
|
|
|
6502 case AccessFlagBits::eTransformFeedbackCounterReadEXT : return "TransformFeedbackCounterReadEXT";
|
|
|
6503 case AccessFlagBits::eTransformFeedbackCounterWriteEXT : return "TransformFeedbackCounterWriteEXT";
|
|
|
6504 case AccessFlagBits::eConditionalRenderingReadEXT : return "ConditionalRenderingReadEXT";
|
|
|
6505 case AccessFlagBits::eColorAttachmentReadNoncoherentEXT : return "ColorAttachmentReadNoncoherentEXT";
|
|
|
6506 case AccessFlagBits::eAccelerationStructureReadKHR : return "AccelerationStructureReadKHR";
|
|
|
6507 case AccessFlagBits::eAccelerationStructureWriteKHR : return "AccelerationStructureWriteKHR";
|
|
|
6508 case AccessFlagBits::eFragmentDensityMapReadEXT : return "FragmentDensityMapReadEXT";
|
|
|
6509 case AccessFlagBits::eFragmentShadingRateAttachmentReadKHR: return "FragmentShadingRateAttachmentReadKHR";
|
|
|
6510 case AccessFlagBits::eCommandPreprocessReadEXT : return "CommandPreprocessReadEXT";
|
|
|
6511 case AccessFlagBits::eCommandPreprocessWriteEXT : return "CommandPreprocessWriteEXT";
|
|
|
6512 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6513 }
|
|
|
6514 }
|
|
|
6515
|
|
|
6516 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DependencyFlagBits value )
|
|
|
6517 {
|
|
|
6518 switch ( value )
|
|
|
6519 {
|
|
|
6520 case DependencyFlagBits::eByRegion : return "ByRegion";
|
|
|
6521 case DependencyFlagBits::eDeviceGroup : return "DeviceGroup";
|
|
|
6522 case DependencyFlagBits::eViewLocal : return "ViewLocal";
|
|
|
6523 case DependencyFlagBits::eFeedbackLoopEXT : return "FeedbackLoopEXT";
|
|
|
6524 case DependencyFlagBits::eQueueFamilyOwnershipTransferUseAllStagesKHR: return "QueueFamilyOwnershipTransferUseAllStagesKHR";
|
|
|
6525 case DependencyFlagBits::eAsymmetricEventKHR : return "AsymmetricEventKHR";
|
|
|
6526 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6527 }
|
|
|
6528 }
|
|
|
6529
|
|
|
6530 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CommandPoolCreateFlagBits value )
|
|
|
6531 {
|
|
|
6532 switch ( value )
|
|
|
6533 {
|
|
|
6534 case CommandPoolCreateFlagBits::eTransient : return "Transient";
|
|
|
6535 case CommandPoolCreateFlagBits::eResetCommandBuffer: return "ResetCommandBuffer";
|
|
|
6536 case CommandPoolCreateFlagBits::eProtected : return "Protected";
|
|
|
6537 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6538 }
|
|
|
6539 }
|
|
|
6540
|
|
|
6541 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CommandPoolResetFlagBits value )
|
|
|
6542 {
|
|
|
6543 switch ( value )
|
|
|
6544 {
|
|
|
6545 case CommandPoolResetFlagBits::eReleaseResources: return "ReleaseResources";
|
|
|
6546 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6547 }
|
|
|
6548 }
|
|
|
6549
|
|
|
6550 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CommandBufferLevel value )
|
|
|
6551 {
|
|
|
6552 switch ( value )
|
|
|
6553 {
|
|
|
6554 case CommandBufferLevel::ePrimary : return "Primary";
|
|
|
6555 case CommandBufferLevel::eSecondary: return "Secondary";
|
|
|
6556 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6557 }
|
|
|
6558 }
|
|
|
6559
|
|
|
6560 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CommandBufferResetFlagBits value )
|
|
|
6561 {
|
|
|
6562 switch ( value )
|
|
|
6563 {
|
|
|
6564 case CommandBufferResetFlagBits::eReleaseResources: return "ReleaseResources";
|
|
|
6565 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6566 }
|
|
|
6567 }
|
|
|
6568
|
|
|
6569 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CommandBufferUsageFlagBits value )
|
|
|
6570 {
|
|
|
6571 switch ( value )
|
|
|
6572 {
|
|
|
6573 case CommandBufferUsageFlagBits::eOneTimeSubmit : return "OneTimeSubmit";
|
|
|
6574 case CommandBufferUsageFlagBits::eRenderPassContinue: return "RenderPassContinue";
|
|
|
6575 case CommandBufferUsageFlagBits::eSimultaneousUse : return "SimultaneousUse";
|
|
|
6576 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6577 }
|
|
|
6578 }
|
|
|
6579
|
|
|
6580 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( QueryControlFlagBits value )
|
|
|
6581 {
|
|
|
6582 switch ( value )
|
|
|
6583 {
|
|
|
6584 case QueryControlFlagBits::ePrecise: return "Precise";
|
|
|
6585 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6586 }
|
|
|
6587 }
|
|
|
6588
|
|
|
6589 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IndexType value )
|
|
|
6590 {
|
|
|
6591 switch ( value )
|
|
|
6592 {
|
|
|
6593 case IndexType::eUint16 : return "Uint16";
|
|
|
6594 case IndexType::eUint32 : return "Uint32";
|
|
|
6595 case IndexType::eUint8 : return "Uint8";
|
|
|
6596 case IndexType::eNoneKHR: return "NoneKHR";
|
|
|
6597 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6598 }
|
|
|
6599 }
|
|
|
6600
|
|
|
6601 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCacheHeaderVersion value )
|
|
|
6602 {
|
|
|
6603 switch ( value )
|
|
|
6604 {
|
|
|
6605 case PipelineCacheHeaderVersion::eOne : return "One";
|
|
|
6606 case PipelineCacheHeaderVersion::eDataGraphQCOM: return "DataGraphQCOM";
|
|
|
6607 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6608 }
|
|
|
6609 }
|
|
|
6610
|
|
|
6611 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( EventCreateFlagBits value )
|
|
|
6612 {
|
|
|
6613 switch ( value )
|
|
|
6614 {
|
|
|
6615 case EventCreateFlagBits::eDeviceOnly: return "DeviceOnly";
|
|
|
6616 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6617 }
|
|
|
6618 }
|
|
|
6619
|
|
|
6620 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BufferViewCreateFlagBits )
|
|
|
6621 {
|
|
|
6622 return "(void)";
|
|
|
6623 }
|
|
|
6624
|
|
|
6625 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderModuleCreateFlagBits )
|
|
|
6626 {
|
|
|
6627 return "(void)";
|
|
|
6628 }
|
|
|
6629
|
|
|
6630 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCacheCreateFlagBits value )
|
|
|
6631 {
|
|
|
6632 switch ( value )
|
|
|
6633 {
|
|
|
6634 case PipelineCacheCreateFlagBits::eExternallySynchronized : return "ExternallySynchronized";
|
|
|
6635 case PipelineCacheCreateFlagBits::eInternallySynchronizedMergeKHR: return "InternallySynchronizedMergeKHR";
|
|
|
6636 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6637 }
|
|
|
6638 }
|
|
|
6639
|
|
|
6640 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCreateFlagBits value )
|
|
|
6641 {
|
|
|
6642 switch ( value )
|
|
|
6643 {
|
|
|
6644 case PipelineCreateFlagBits::eDisableOptimization : return "DisableOptimization";
|
|
|
6645 case PipelineCreateFlagBits::eAllowDerivatives : return "AllowDerivatives";
|
|
|
6646 case PipelineCreateFlagBits::eDerivative : return "Derivative";
|
|
|
6647 case PipelineCreateFlagBits::eDispatchBase : return "DispatchBase";
|
|
|
6648 case PipelineCreateFlagBits::eViewIndexFromDeviceIndex : return "ViewIndexFromDeviceIndex";
|
|
|
6649 case PipelineCreateFlagBits::eFailOnPipelineCompileRequired : return "FailOnPipelineCompileRequired";
|
|
|
6650 case PipelineCreateFlagBits::eEarlyReturnOnFailure : return "EarlyReturnOnFailure";
|
|
|
6651 case PipelineCreateFlagBits::eNoProtectedAccess : return "NoProtectedAccess";
|
|
|
6652 case PipelineCreateFlagBits::eProtectedAccessOnly : return "ProtectedAccessOnly";
|
|
|
6653 case PipelineCreateFlagBits::eRayTracingNoNullAnyHitShadersKHR : return "RayTracingNoNullAnyHitShadersKHR";
|
|
|
6654 case PipelineCreateFlagBits::eRayTracingNoNullClosestHitShadersKHR : return "RayTracingNoNullClosestHitShadersKHR";
|
|
|
6655 case PipelineCreateFlagBits::eRayTracingNoNullMissShadersKHR : return "RayTracingNoNullMissShadersKHR";
|
|
|
6656 case PipelineCreateFlagBits::eRayTracingNoNullIntersectionShadersKHR : return "RayTracingNoNullIntersectionShadersKHR";
|
|
|
6657 case PipelineCreateFlagBits::eRayTracingSkipTrianglesKHR : return "RayTracingSkipTrianglesKHR";
|
|
|
6658 case PipelineCreateFlagBits::eRayTracingSkipAabbsKHR : return "RayTracingSkipAabbsKHR";
|
|
|
6659 case PipelineCreateFlagBits::eRayTracingShaderGroupHandleCaptureReplayKHR: return "RayTracingShaderGroupHandleCaptureReplayKHR";
|
|
|
6660 case PipelineCreateFlagBits::eDeferCompileNV : return "DeferCompileNV";
|
|
|
6661 case PipelineCreateFlagBits::eRenderingFragmentDensityMapAttachmentEXT : return "RenderingFragmentDensityMapAttachmentEXT";
|
|
|
6662 case PipelineCreateFlagBits::eRenderingFragmentShadingRateAttachmentKHR : return "RenderingFragmentShadingRateAttachmentKHR";
|
|
|
6663 case PipelineCreateFlagBits::eCaptureStatisticsKHR : return "CaptureStatisticsKHR";
|
|
|
6664 case PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR : return "CaptureInternalRepresentationsKHR";
|
|
|
6665 case PipelineCreateFlagBits::eIndirectBindableNV : return "IndirectBindableNV";
|
|
|
6666 case PipelineCreateFlagBits::eLibraryKHR : return "LibraryKHR";
|
|
|
6667 case PipelineCreateFlagBits::eDescriptorBufferEXT : return "DescriptorBufferEXT";
|
|
|
6668 case PipelineCreateFlagBits::eRetainLinkTimeOptimizationInfoEXT : return "RetainLinkTimeOptimizationInfoEXT";
|
|
|
6669 case PipelineCreateFlagBits::eLinkTimeOptimizationEXT : return "LinkTimeOptimizationEXT";
|
|
|
6670 case PipelineCreateFlagBits::eRayTracingAllowMotionNV : return "RayTracingAllowMotionNV";
|
|
|
6671 case PipelineCreateFlagBits::eColorAttachmentFeedbackLoopEXT : return "ColorAttachmentFeedbackLoopEXT";
|
|
|
6672 case PipelineCreateFlagBits::eDepthStencilAttachmentFeedbackLoopEXT : return "DepthStencilAttachmentFeedbackLoopEXT";
|
|
|
6673 case PipelineCreateFlagBits::eRayTracingOpacityMicromapEXT : return "RayTracingOpacityMicromapEXT";
|
|
|
6674 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
6675 case PipelineCreateFlagBits::eRayTracingDisplacementMicromapNV: return "RayTracingDisplacementMicromapNV";
|
|
|
6676 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
6677 default: return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6678 }
|
|
|
6679 }
|
|
|
6680
|
|
|
6681 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineShaderStageCreateFlagBits value )
|
|
|
6682 {
|
|
|
6683 switch ( value )
|
|
|
6684 {
|
|
|
6685 case PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSize: return "AllowVaryingSubgroupSize";
|
|
|
6686 case PipelineShaderStageCreateFlagBits::eRequireFullSubgroups : return "RequireFullSubgroups";
|
|
|
6687 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6688 }
|
|
|
6689 }
|
|
|
6690
|
|
|
6691 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderStageFlagBits value )
|
|
|
6692 {
|
|
|
6693 switch ( value )
|
|
|
6694 {
|
|
|
6695 case ShaderStageFlagBits::eVertex : return "Vertex";
|
|
|
6696 case ShaderStageFlagBits::eTessellationControl : return "TessellationControl";
|
|
|
6697 case ShaderStageFlagBits::eTessellationEvaluation: return "TessellationEvaluation";
|
|
|
6698 case ShaderStageFlagBits::eGeometry : return "Geometry";
|
|
|
6699 case ShaderStageFlagBits::eFragment : return "Fragment";
|
|
|
6700 case ShaderStageFlagBits::eCompute : return "Compute";
|
|
|
6701 case ShaderStageFlagBits::eAllGraphics : return "AllGraphics";
|
|
|
6702 case ShaderStageFlagBits::eAll : return "All";
|
|
|
6703 case ShaderStageFlagBits::eRaygenKHR : return "RaygenKHR";
|
|
|
6704 case ShaderStageFlagBits::eAnyHitKHR : return "AnyHitKHR";
|
|
|
6705 case ShaderStageFlagBits::eClosestHitKHR : return "ClosestHitKHR";
|
|
|
6706 case ShaderStageFlagBits::eMissKHR : return "MissKHR";
|
|
|
6707 case ShaderStageFlagBits::eIntersectionKHR : return "IntersectionKHR";
|
|
|
6708 case ShaderStageFlagBits::eCallableKHR : return "CallableKHR";
|
|
|
6709 case ShaderStageFlagBits::eTaskEXT : return "TaskEXT";
|
|
|
6710 case ShaderStageFlagBits::eMeshEXT : return "MeshEXT";
|
|
|
6711 case ShaderStageFlagBits::eSubpassShadingHUAWEI : return "SubpassShadingHUAWEI";
|
|
|
6712 case ShaderStageFlagBits::eClusterCullingHUAWEI : return "ClusterCullingHUAWEI";
|
|
|
6713 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6714 }
|
|
|
6715 }
|
|
|
6716
|
|
|
6717 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineLayoutCreateFlagBits value )
|
|
|
6718 {
|
|
|
6719 switch ( value )
|
|
|
6720 {
|
|
|
6721 case PipelineLayoutCreateFlagBits::eIndependentSetsEXT: return "IndependentSetsEXT";
|
|
|
6722 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6723 }
|
|
|
6724 }
|
|
|
6725
|
|
|
6726 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BorderColor value )
|
|
|
6727 {
|
|
|
6728 switch ( value )
|
|
|
6729 {
|
|
|
6730 case BorderColor::eFloatTransparentBlack: return "FloatTransparentBlack";
|
|
|
6731 case BorderColor::eIntTransparentBlack : return "IntTransparentBlack";
|
|
|
6732 case BorderColor::eFloatOpaqueBlack : return "FloatOpaqueBlack";
|
|
|
6733 case BorderColor::eIntOpaqueBlack : return "IntOpaqueBlack";
|
|
|
6734 case BorderColor::eFloatOpaqueWhite : return "FloatOpaqueWhite";
|
|
|
6735 case BorderColor::eIntOpaqueWhite : return "IntOpaqueWhite";
|
|
|
6736 case BorderColor::eFloatCustomEXT : return "FloatCustomEXT";
|
|
|
6737 case BorderColor::eIntCustomEXT : return "IntCustomEXT";
|
|
|
6738 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6739 }
|
|
|
6740 }
|
|
|
6741
|
|
|
6742 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( Filter value )
|
|
|
6743 {
|
|
|
6744 switch ( value )
|
|
|
6745 {
|
|
|
6746 case Filter::eNearest : return "Nearest";
|
|
|
6747 case Filter::eLinear : return "Linear";
|
|
|
6748 case Filter::eCubicEXT: return "CubicEXT";
|
|
|
6749 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6750 }
|
|
|
6751 }
|
|
|
6752
|
|
|
6753 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SamplerAddressMode value )
|
|
|
6754 {
|
|
|
6755 switch ( value )
|
|
|
6756 {
|
|
|
6757 case SamplerAddressMode::eRepeat : return "Repeat";
|
|
|
6758 case SamplerAddressMode::eMirroredRepeat : return "MirroredRepeat";
|
|
|
6759 case SamplerAddressMode::eClampToEdge : return "ClampToEdge";
|
|
|
6760 case SamplerAddressMode::eClampToBorder : return "ClampToBorder";
|
|
|
6761 case SamplerAddressMode::eMirrorClampToEdge: return "MirrorClampToEdge";
|
|
|
6762 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6763 }
|
|
|
6764 }
|
|
|
6765
|
|
|
6766 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SamplerCreateFlagBits value )
|
|
|
6767 {
|
|
|
6768 switch ( value )
|
|
|
6769 {
|
|
|
6770 case SamplerCreateFlagBits::eSubsampledEXT : return "SubsampledEXT";
|
|
|
6771 case SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT: return "SubsampledCoarseReconstructionEXT";
|
|
|
6772 case SamplerCreateFlagBits::eDescriptorBufferCaptureReplayEXT : return "DescriptorBufferCaptureReplayEXT";
|
|
|
6773 case SamplerCreateFlagBits::eNonSeamlessCubeMapEXT : return "NonSeamlessCubeMapEXT";
|
|
|
6774 case SamplerCreateFlagBits::eImageProcessingQCOM : return "ImageProcessingQCOM";
|
|
|
6775 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6776 }
|
|
|
6777 }
|
|
|
6778
|
|
|
6779 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SamplerMipmapMode value )
|
|
|
6780 {
|
|
|
6781 switch ( value )
|
|
|
6782 {
|
|
|
6783 case SamplerMipmapMode::eNearest: return "Nearest";
|
|
|
6784 case SamplerMipmapMode::eLinear : return "Linear";
|
|
|
6785 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6786 }
|
|
|
6787 }
|
|
|
6788
|
|
|
6789 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorPoolCreateFlagBits value )
|
|
|
6790 {
|
|
|
6791 switch ( value )
|
|
|
6792 {
|
|
|
6793 case DescriptorPoolCreateFlagBits::eFreeDescriptorSet : return "FreeDescriptorSet";
|
|
|
6794 case DescriptorPoolCreateFlagBits::eUpdateAfterBind : return "UpdateAfterBind";
|
|
|
6795 case DescriptorPoolCreateFlagBits::eHostOnlyEXT : return "HostOnlyEXT";
|
|
|
6796 case DescriptorPoolCreateFlagBits::eAllowOverallocationSetsNV : return "AllowOverallocationSetsNV";
|
|
|
6797 case DescriptorPoolCreateFlagBits::eAllowOverallocationPoolsNV: return "AllowOverallocationPoolsNV";
|
|
|
6798 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6799 }
|
|
|
6800 }
|
|
|
6801
|
|
|
6802 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorSetLayoutCreateFlagBits value )
|
|
|
6803 {
|
|
|
6804 switch ( value )
|
|
|
6805 {
|
|
|
6806 case DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool : return "UpdateAfterBindPool";
|
|
|
6807 case DescriptorSetLayoutCreateFlagBits::ePushDescriptor : return "PushDescriptor";
|
|
|
6808 case DescriptorSetLayoutCreateFlagBits::eDescriptorBufferEXT : return "DescriptorBufferEXT";
|
|
|
6809 case DescriptorSetLayoutCreateFlagBits::eEmbeddedImmutableSamplersEXT: return "EmbeddedImmutableSamplersEXT";
|
|
|
6810 case DescriptorSetLayoutCreateFlagBits::eIndirectBindableNV : return "IndirectBindableNV";
|
|
|
6811 case DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolEXT : return "HostOnlyPoolEXT";
|
|
|
6812 case DescriptorSetLayoutCreateFlagBits::ePerStageNV : return "PerStageNV";
|
|
|
6813 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6814 }
|
|
|
6815 }
|
|
|
6816
|
|
|
6817 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorType value )
|
|
|
6818 {
|
|
|
6819 switch ( value )
|
|
|
6820 {
|
|
|
6821 case DescriptorType::eSampler : return "Sampler";
|
|
|
6822 case DescriptorType::eCombinedImageSampler : return "CombinedImageSampler";
|
|
|
6823 case DescriptorType::eSampledImage : return "SampledImage";
|
|
|
6824 case DescriptorType::eStorageImage : return "StorageImage";
|
|
|
6825 case DescriptorType::eUniformTexelBuffer : return "UniformTexelBuffer";
|
|
|
6826 case DescriptorType::eStorageTexelBuffer : return "StorageTexelBuffer";
|
|
|
6827 case DescriptorType::eUniformBuffer : return "UniformBuffer";
|
|
|
6828 case DescriptorType::eStorageBuffer : return "StorageBuffer";
|
|
|
6829 case DescriptorType::eUniformBufferDynamic : return "UniformBufferDynamic";
|
|
|
6830 case DescriptorType::eStorageBufferDynamic : return "StorageBufferDynamic";
|
|
|
6831 case DescriptorType::eInputAttachment : return "InputAttachment";
|
|
|
6832 case DescriptorType::eInlineUniformBlock : return "InlineUniformBlock";
|
|
|
6833 case DescriptorType::eAccelerationStructureKHR : return "AccelerationStructureKHR";
|
|
|
6834 case DescriptorType::eAccelerationStructureNV : return "AccelerationStructureNV";
|
|
|
6835 case DescriptorType::eSampleWeightImageQCOM : return "SampleWeightImageQCOM";
|
|
|
6836 case DescriptorType::eBlockMatchImageQCOM : return "BlockMatchImageQCOM";
|
|
|
6837 case DescriptorType::eTensorARM : return "TensorARM";
|
|
|
6838 case DescriptorType::eMutableEXT : return "MutableEXT";
|
|
|
6839 case DescriptorType::ePartitionedAccelerationStructureNV: return "PartitionedAccelerationStructureNV";
|
|
|
6840 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6841 }
|
|
|
6842 }
|
|
|
6843
|
|
|
6844 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorPoolResetFlagBits )
|
|
|
6845 {
|
|
|
6846 return "(void)";
|
|
|
6847 }
|
|
|
6848
|
|
|
6849 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( QueryPipelineStatisticFlagBits value )
|
|
|
6850 {
|
|
|
6851 switch ( value )
|
|
|
6852 {
|
|
|
6853 case QueryPipelineStatisticFlagBits::eInputAssemblyVertices : return "InputAssemblyVertices";
|
|
|
6854 case QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives : return "InputAssemblyPrimitives";
|
|
|
6855 case QueryPipelineStatisticFlagBits::eVertexShaderInvocations : return "VertexShaderInvocations";
|
|
|
6856 case QueryPipelineStatisticFlagBits::eGeometryShaderInvocations : return "GeometryShaderInvocations";
|
|
|
6857 case QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives : return "GeometryShaderPrimitives";
|
|
|
6858 case QueryPipelineStatisticFlagBits::eClippingInvocations : return "ClippingInvocations";
|
|
|
6859 case QueryPipelineStatisticFlagBits::eClippingPrimitives : return "ClippingPrimitives";
|
|
|
6860 case QueryPipelineStatisticFlagBits::eFragmentShaderInvocations : return "FragmentShaderInvocations";
|
|
|
6861 case QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches : return "TessellationControlShaderPatches";
|
|
|
6862 case QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations: return "TessellationEvaluationShaderInvocations";
|
|
|
6863 case QueryPipelineStatisticFlagBits::eComputeShaderInvocations : return "ComputeShaderInvocations";
|
|
|
6864 case QueryPipelineStatisticFlagBits::eTaskShaderInvocationsEXT : return "TaskShaderInvocationsEXT";
|
|
|
6865 case QueryPipelineStatisticFlagBits::eMeshShaderInvocationsEXT : return "MeshShaderInvocationsEXT";
|
|
|
6866 case QueryPipelineStatisticFlagBits::eClusterCullingShaderInvocationsHUAWEI : return "ClusterCullingShaderInvocationsHUAWEI";
|
|
|
6867 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6868 }
|
|
|
6869 }
|
|
|
6870
|
|
|
6871 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineBindPoint value )
|
|
|
6872 {
|
|
|
6873 switch ( value )
|
|
|
6874 {
|
|
|
6875 case PipelineBindPoint::eGraphics: return "Graphics";
|
|
|
6876 case PipelineBindPoint::eCompute : return "Compute";
|
|
|
6877 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
6878 case PipelineBindPoint::eExecutionGraphAMDX: return "ExecutionGraphAMDX";
|
|
|
6879 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
6880 case PipelineBindPoint::eRayTracingKHR : return "RayTracingKHR";
|
|
|
6881 case PipelineBindPoint::eSubpassShadingHUAWEI: return "SubpassShadingHUAWEI";
|
|
|
6882 case PipelineBindPoint::eDataGraphARM : return "DataGraphARM";
|
|
|
6883 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6884 }
|
|
|
6885 }
|
|
|
6886
|
|
|
6887 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BlendFactor value )
|
|
|
6888 {
|
|
|
6889 switch ( value )
|
|
|
6890 {
|
|
|
6891 case BlendFactor::eZero : return "Zero";
|
|
|
6892 case BlendFactor::eOne : return "One";
|
|
|
6893 case BlendFactor::eSrcColor : return "SrcColor";
|
|
|
6894 case BlendFactor::eOneMinusSrcColor : return "OneMinusSrcColor";
|
|
|
6895 case BlendFactor::eDstColor : return "DstColor";
|
|
|
6896 case BlendFactor::eOneMinusDstColor : return "OneMinusDstColor";
|
|
|
6897 case BlendFactor::eSrcAlpha : return "SrcAlpha";
|
|
|
6898 case BlendFactor::eOneMinusSrcAlpha : return "OneMinusSrcAlpha";
|
|
|
6899 case BlendFactor::eDstAlpha : return "DstAlpha";
|
|
|
6900 case BlendFactor::eOneMinusDstAlpha : return "OneMinusDstAlpha";
|
|
|
6901 case BlendFactor::eConstantColor : return "ConstantColor";
|
|
|
6902 case BlendFactor::eOneMinusConstantColor: return "OneMinusConstantColor";
|
|
|
6903 case BlendFactor::eConstantAlpha : return "ConstantAlpha";
|
|
|
6904 case BlendFactor::eOneMinusConstantAlpha: return "OneMinusConstantAlpha";
|
|
|
6905 case BlendFactor::eSrcAlphaSaturate : return "SrcAlphaSaturate";
|
|
|
6906 case BlendFactor::eSrc1Color : return "Src1Color";
|
|
|
6907 case BlendFactor::eOneMinusSrc1Color : return "OneMinusSrc1Color";
|
|
|
6908 case BlendFactor::eSrc1Alpha : return "Src1Alpha";
|
|
|
6909 case BlendFactor::eOneMinusSrc1Alpha : return "OneMinusSrc1Alpha";
|
|
|
6910 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6911 }
|
|
|
6912 }
|
|
|
6913
|
|
|
6914 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BlendOp value )
|
|
|
6915 {
|
|
|
6916 switch ( value )
|
|
|
6917 {
|
|
|
6918 case BlendOp::eAdd : return "Add";
|
|
|
6919 case BlendOp::eSubtract : return "Subtract";
|
|
|
6920 case BlendOp::eReverseSubtract : return "ReverseSubtract";
|
|
|
6921 case BlendOp::eMin : return "Min";
|
|
|
6922 case BlendOp::eMax : return "Max";
|
|
|
6923 case BlendOp::eZeroEXT : return "ZeroEXT";
|
|
|
6924 case BlendOp::eSrcEXT : return "SrcEXT";
|
|
|
6925 case BlendOp::eDstEXT : return "DstEXT";
|
|
|
6926 case BlendOp::eSrcOverEXT : return "SrcOverEXT";
|
|
|
6927 case BlendOp::eDstOverEXT : return "DstOverEXT";
|
|
|
6928 case BlendOp::eSrcInEXT : return "SrcInEXT";
|
|
|
6929 case BlendOp::eDstInEXT : return "DstInEXT";
|
|
|
6930 case BlendOp::eSrcOutEXT : return "SrcOutEXT";
|
|
|
6931 case BlendOp::eDstOutEXT : return "DstOutEXT";
|
|
|
6932 case BlendOp::eSrcAtopEXT : return "SrcAtopEXT";
|
|
|
6933 case BlendOp::eDstAtopEXT : return "DstAtopEXT";
|
|
|
6934 case BlendOp::eXorEXT : return "XorEXT";
|
|
|
6935 case BlendOp::eMultiplyEXT : return "MultiplyEXT";
|
|
|
6936 case BlendOp::eScreenEXT : return "ScreenEXT";
|
|
|
6937 case BlendOp::eOverlayEXT : return "OverlayEXT";
|
|
|
6938 case BlendOp::eDarkenEXT : return "DarkenEXT";
|
|
|
6939 case BlendOp::eLightenEXT : return "LightenEXT";
|
|
|
6940 case BlendOp::eColordodgeEXT : return "ColordodgeEXT";
|
|
|
6941 case BlendOp::eColorburnEXT : return "ColorburnEXT";
|
|
|
6942 case BlendOp::eHardlightEXT : return "HardlightEXT";
|
|
|
6943 case BlendOp::eSoftlightEXT : return "SoftlightEXT";
|
|
|
6944 case BlendOp::eDifferenceEXT : return "DifferenceEXT";
|
|
|
6945 case BlendOp::eExclusionEXT : return "ExclusionEXT";
|
|
|
6946 case BlendOp::eInvertEXT : return "InvertEXT";
|
|
|
6947 case BlendOp::eInvertRgbEXT : return "InvertRgbEXT";
|
|
|
6948 case BlendOp::eLineardodgeEXT : return "LineardodgeEXT";
|
|
|
6949 case BlendOp::eLinearburnEXT : return "LinearburnEXT";
|
|
|
6950 case BlendOp::eVividlightEXT : return "VividlightEXT";
|
|
|
6951 case BlendOp::eLinearlightEXT : return "LinearlightEXT";
|
|
|
6952 case BlendOp::ePinlightEXT : return "PinlightEXT";
|
|
|
6953 case BlendOp::eHardmixEXT : return "HardmixEXT";
|
|
|
6954 case BlendOp::eHslHueEXT : return "HslHueEXT";
|
|
|
6955 case BlendOp::eHslSaturationEXT : return "HslSaturationEXT";
|
|
|
6956 case BlendOp::eHslColorEXT : return "HslColorEXT";
|
|
|
6957 case BlendOp::eHslLuminosityEXT : return "HslLuminosityEXT";
|
|
|
6958 case BlendOp::ePlusEXT : return "PlusEXT";
|
|
|
6959 case BlendOp::ePlusClampedEXT : return "PlusClampedEXT";
|
|
|
6960 case BlendOp::ePlusClampedAlphaEXT: return "PlusClampedAlphaEXT";
|
|
|
6961 case BlendOp::ePlusDarkerEXT : return "PlusDarkerEXT";
|
|
|
6962 case BlendOp::eMinusEXT : return "MinusEXT";
|
|
|
6963 case BlendOp::eMinusClampedEXT : return "MinusClampedEXT";
|
|
|
6964 case BlendOp::eContrastEXT : return "ContrastEXT";
|
|
|
6965 case BlendOp::eInvertOvgEXT : return "InvertOvgEXT";
|
|
|
6966 case BlendOp::eRedEXT : return "RedEXT";
|
|
|
6967 case BlendOp::eGreenEXT : return "GreenEXT";
|
|
|
6968 case BlendOp::eBlueEXT : return "BlueEXT";
|
|
|
6969 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6970 }
|
|
|
6971 }
|
|
|
6972
|
|
|
6973 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ColorComponentFlagBits value )
|
|
|
6974 {
|
|
|
6975 switch ( value )
|
|
|
6976 {
|
|
|
6977 case ColorComponentFlagBits::eR: return "R";
|
|
|
6978 case ColorComponentFlagBits::eG: return "G";
|
|
|
6979 case ColorComponentFlagBits::eB: return "B";
|
|
|
6980 case ColorComponentFlagBits::eA: return "A";
|
|
|
6981 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6982 }
|
|
|
6983 }
|
|
|
6984
|
|
|
6985 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CompareOp value )
|
|
|
6986 {
|
|
|
6987 switch ( value )
|
|
|
6988 {
|
|
|
6989 case CompareOp::eNever : return "Never";
|
|
|
6990 case CompareOp::eLess : return "Less";
|
|
|
6991 case CompareOp::eEqual : return "Equal";
|
|
|
6992 case CompareOp::eLessOrEqual : return "LessOrEqual";
|
|
|
6993 case CompareOp::eGreater : return "Greater";
|
|
|
6994 case CompareOp::eNotEqual : return "NotEqual";
|
|
|
6995 case CompareOp::eGreaterOrEqual: return "GreaterOrEqual";
|
|
|
6996 case CompareOp::eAlways : return "Always";
|
|
|
6997 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
6998 }
|
|
|
6999 }
|
|
|
7000
|
|
|
7001 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CullModeFlagBits value )
|
|
|
7002 {
|
|
|
7003 switch ( value )
|
|
|
7004 {
|
|
|
7005 case CullModeFlagBits::eNone : return "None";
|
|
|
7006 case CullModeFlagBits::eFront : return "Front";
|
|
|
7007 case CullModeFlagBits::eBack : return "Back";
|
|
|
7008 case CullModeFlagBits::eFrontAndBack: return "FrontAndBack";
|
|
|
7009 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7010 }
|
|
|
7011 }
|
|
|
7012
|
|
|
7013 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DynamicState value )
|
|
|
7014 {
|
|
|
7015 switch ( value )
|
|
|
7016 {
|
|
|
7017 case DynamicState::eViewport : return "Viewport";
|
|
|
7018 case DynamicState::eScissor : return "Scissor";
|
|
|
7019 case DynamicState::eLineWidth : return "LineWidth";
|
|
|
7020 case DynamicState::eDepthBias : return "DepthBias";
|
|
|
7021 case DynamicState::eBlendConstants : return "BlendConstants";
|
|
|
7022 case DynamicState::eDepthBounds : return "DepthBounds";
|
|
|
7023 case DynamicState::eStencilCompareMask : return "StencilCompareMask";
|
|
|
7024 case DynamicState::eStencilWriteMask : return "StencilWriteMask";
|
|
|
7025 case DynamicState::eStencilReference : return "StencilReference";
|
|
|
7026 case DynamicState::eCullMode : return "CullMode";
|
|
|
7027 case DynamicState::eFrontFace : return "FrontFace";
|
|
|
7028 case DynamicState::ePrimitiveTopology : return "PrimitiveTopology";
|
|
|
7029 case DynamicState::eViewportWithCount : return "ViewportWithCount";
|
|
|
7030 case DynamicState::eScissorWithCount : return "ScissorWithCount";
|
|
|
7031 case DynamicState::eVertexInputBindingStride : return "VertexInputBindingStride";
|
|
|
7032 case DynamicState::eDepthTestEnable : return "DepthTestEnable";
|
|
|
7033 case DynamicState::eDepthWriteEnable : return "DepthWriteEnable";
|
|
|
7034 case DynamicState::eDepthCompareOp : return "DepthCompareOp";
|
|
|
7035 case DynamicState::eDepthBoundsTestEnable : return "DepthBoundsTestEnable";
|
|
|
7036 case DynamicState::eStencilTestEnable : return "StencilTestEnable";
|
|
|
7037 case DynamicState::eStencilOp : return "StencilOp";
|
|
|
7038 case DynamicState::eRasterizerDiscardEnable : return "RasterizerDiscardEnable";
|
|
|
7039 case DynamicState::eDepthBiasEnable : return "DepthBiasEnable";
|
|
|
7040 case DynamicState::ePrimitiveRestartEnable : return "PrimitiveRestartEnable";
|
|
|
7041 case DynamicState::eLineStipple : return "LineStipple";
|
|
|
7042 case DynamicState::eViewportWScalingNV : return "ViewportWScalingNV";
|
|
|
7043 case DynamicState::eDiscardRectangleEXT : return "DiscardRectangleEXT";
|
|
|
7044 case DynamicState::eDiscardRectangleEnableEXT : return "DiscardRectangleEnableEXT";
|
|
|
7045 case DynamicState::eDiscardRectangleModeEXT : return "DiscardRectangleModeEXT";
|
|
|
7046 case DynamicState::eSampleLocationsEXT : return "SampleLocationsEXT";
|
|
|
7047 case DynamicState::eRayTracingPipelineStackSizeKHR : return "RayTracingPipelineStackSizeKHR";
|
|
|
7048 case DynamicState::eViewportShadingRatePaletteNV : return "ViewportShadingRatePaletteNV";
|
|
|
7049 case DynamicState::eViewportCoarseSampleOrderNV : return "ViewportCoarseSampleOrderNV";
|
|
|
7050 case DynamicState::eExclusiveScissorEnableNV : return "ExclusiveScissorEnableNV";
|
|
|
7051 case DynamicState::eExclusiveScissorNV : return "ExclusiveScissorNV";
|
|
|
7052 case DynamicState::eFragmentShadingRateKHR : return "FragmentShadingRateKHR";
|
|
|
7053 case DynamicState::eVertexInputEXT : return "VertexInputEXT";
|
|
|
7054 case DynamicState::ePatchControlPointsEXT : return "PatchControlPointsEXT";
|
|
|
7055 case DynamicState::eLogicOpEXT : return "LogicOpEXT";
|
|
|
7056 case DynamicState::eColorWriteEnableEXT : return "ColorWriteEnableEXT";
|
|
|
7057 case DynamicState::eDepthClampEnableEXT : return "DepthClampEnableEXT";
|
|
|
7058 case DynamicState::ePolygonModeEXT : return "PolygonModeEXT";
|
|
|
7059 case DynamicState::eRasterizationSamplesEXT : return "RasterizationSamplesEXT";
|
|
|
7060 case DynamicState::eSampleMaskEXT : return "SampleMaskEXT";
|
|
|
7061 case DynamicState::eAlphaToCoverageEnableEXT : return "AlphaToCoverageEnableEXT";
|
|
|
7062 case DynamicState::eAlphaToOneEnableEXT : return "AlphaToOneEnableEXT";
|
|
|
7063 case DynamicState::eLogicOpEnableEXT : return "LogicOpEnableEXT";
|
|
|
7064 case DynamicState::eColorBlendEnableEXT : return "ColorBlendEnableEXT";
|
|
|
7065 case DynamicState::eColorBlendEquationEXT : return "ColorBlendEquationEXT";
|
|
|
7066 case DynamicState::eColorWriteMaskEXT : return "ColorWriteMaskEXT";
|
|
|
7067 case DynamicState::eTessellationDomainOriginEXT : return "TessellationDomainOriginEXT";
|
|
|
7068 case DynamicState::eRasterizationStreamEXT : return "RasterizationStreamEXT";
|
|
|
7069 case DynamicState::eConservativeRasterizationModeEXT : return "ConservativeRasterizationModeEXT";
|
|
|
7070 case DynamicState::eExtraPrimitiveOverestimationSizeEXT: return "ExtraPrimitiveOverestimationSizeEXT";
|
|
|
7071 case DynamicState::eDepthClipEnableEXT : return "DepthClipEnableEXT";
|
|
|
7072 case DynamicState::eSampleLocationsEnableEXT : return "SampleLocationsEnableEXT";
|
|
|
7073 case DynamicState::eColorBlendAdvancedEXT : return "ColorBlendAdvancedEXT";
|
|
|
7074 case DynamicState::eProvokingVertexModeEXT : return "ProvokingVertexModeEXT";
|
|
|
7075 case DynamicState::eLineRasterizationModeEXT : return "LineRasterizationModeEXT";
|
|
|
7076 case DynamicState::eLineStippleEnableEXT : return "LineStippleEnableEXT";
|
|
|
7077 case DynamicState::eDepthClipNegativeOneToOneEXT : return "DepthClipNegativeOneToOneEXT";
|
|
|
7078 case DynamicState::eViewportWScalingEnableNV : return "ViewportWScalingEnableNV";
|
|
|
7079 case DynamicState::eViewportSwizzleNV : return "ViewportSwizzleNV";
|
|
|
7080 case DynamicState::eCoverageToColorEnableNV : return "CoverageToColorEnableNV";
|
|
|
7081 case DynamicState::eCoverageToColorLocationNV : return "CoverageToColorLocationNV";
|
|
|
7082 case DynamicState::eCoverageModulationModeNV : return "CoverageModulationModeNV";
|
|
|
7083 case DynamicState::eCoverageModulationTableEnableNV : return "CoverageModulationTableEnableNV";
|
|
|
7084 case DynamicState::eCoverageModulationTableNV : return "CoverageModulationTableNV";
|
|
|
7085 case DynamicState::eShadingRateImageEnableNV : return "ShadingRateImageEnableNV";
|
|
|
7086 case DynamicState::eRepresentativeFragmentTestEnableNV : return "RepresentativeFragmentTestEnableNV";
|
|
|
7087 case DynamicState::eCoverageReductionModeNV : return "CoverageReductionModeNV";
|
|
|
7088 case DynamicState::eAttachmentFeedbackLoopEnableEXT : return "AttachmentFeedbackLoopEnableEXT";
|
|
|
7089 case DynamicState::eDepthClampRangeEXT : return "DepthClampRangeEXT";
|
|
|
7090 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7091 }
|
|
|
7092 }
|
|
|
7093
|
|
|
7094 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FrontFace value )
|
|
|
7095 {
|
|
|
7096 switch ( value )
|
|
|
7097 {
|
|
|
7098 case FrontFace::eCounterClockwise: return "CounterClockwise";
|
|
|
7099 case FrontFace::eClockwise : return "Clockwise";
|
|
|
7100 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7101 }
|
|
|
7102 }
|
|
|
7103
|
|
|
7104 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( LogicOp value )
|
|
|
7105 {
|
|
|
7106 switch ( value )
|
|
|
7107 {
|
|
|
7108 case LogicOp::eClear : return "Clear";
|
|
|
7109 case LogicOp::eAnd : return "And";
|
|
|
7110 case LogicOp::eAndReverse : return "AndReverse";
|
|
|
7111 case LogicOp::eCopy : return "Copy";
|
|
|
7112 case LogicOp::eAndInverted : return "AndInverted";
|
|
|
7113 case LogicOp::eNoOp : return "NoOp";
|
|
|
7114 case LogicOp::eXor : return "Xor";
|
|
|
7115 case LogicOp::eOr : return "Or";
|
|
|
7116 case LogicOp::eNor : return "Nor";
|
|
|
7117 case LogicOp::eEquivalent : return "Equivalent";
|
|
|
7118 case LogicOp::eInvert : return "Invert";
|
|
|
7119 case LogicOp::eOrReverse : return "OrReverse";
|
|
|
7120 case LogicOp::eCopyInverted: return "CopyInverted";
|
|
|
7121 case LogicOp::eOrInverted : return "OrInverted";
|
|
|
7122 case LogicOp::eNand : return "Nand";
|
|
|
7123 case LogicOp::eSet : return "Set";
|
|
|
7124 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7125 }
|
|
|
7126 }
|
|
|
7127
|
|
|
7128 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PolygonMode value )
|
|
|
7129 {
|
|
|
7130 switch ( value )
|
|
|
7131 {
|
|
|
7132 case PolygonMode::eFill : return "Fill";
|
|
|
7133 case PolygonMode::eLine : return "Line";
|
|
|
7134 case PolygonMode::ePoint : return "Point";
|
|
|
7135 case PolygonMode::eFillRectangleNV: return "FillRectangleNV";
|
|
|
7136 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7137 }
|
|
|
7138 }
|
|
|
7139
|
|
|
7140 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PrimitiveTopology value )
|
|
|
7141 {
|
|
|
7142 switch ( value )
|
|
|
7143 {
|
|
|
7144 case PrimitiveTopology::ePointList : return "PointList";
|
|
|
7145 case PrimitiveTopology::eLineList : return "LineList";
|
|
|
7146 case PrimitiveTopology::eLineStrip : return "LineStrip";
|
|
|
7147 case PrimitiveTopology::eTriangleList : return "TriangleList";
|
|
|
7148 case PrimitiveTopology::eTriangleStrip : return "TriangleStrip";
|
|
|
7149 case PrimitiveTopology::eTriangleFan : return "TriangleFan";
|
|
|
7150 case PrimitiveTopology::eLineListWithAdjacency : return "LineListWithAdjacency";
|
|
|
7151 case PrimitiveTopology::eLineStripWithAdjacency : return "LineStripWithAdjacency";
|
|
|
7152 case PrimitiveTopology::eTriangleListWithAdjacency : return "TriangleListWithAdjacency";
|
|
|
7153 case PrimitiveTopology::eTriangleStripWithAdjacency: return "TriangleStripWithAdjacency";
|
|
|
7154 case PrimitiveTopology::ePatchList : return "PatchList";
|
|
|
7155 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7156 }
|
|
|
7157 }
|
|
|
7158
|
|
|
7159 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( StencilOp value )
|
|
|
7160 {
|
|
|
7161 switch ( value )
|
|
|
7162 {
|
|
|
7163 case StencilOp::eKeep : return "Keep";
|
|
|
7164 case StencilOp::eZero : return "Zero";
|
|
|
7165 case StencilOp::eReplace : return "Replace";
|
|
|
7166 case StencilOp::eIncrementAndClamp: return "IncrementAndClamp";
|
|
|
7167 case StencilOp::eDecrementAndClamp: return "DecrementAndClamp";
|
|
|
7168 case StencilOp::eInvert : return "Invert";
|
|
|
7169 case StencilOp::eIncrementAndWrap : return "IncrementAndWrap";
|
|
|
7170 case StencilOp::eDecrementAndWrap : return "DecrementAndWrap";
|
|
|
7171 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7172 }
|
|
|
7173 }
|
|
|
7174
|
|
|
7175 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VertexInputRate value )
|
|
|
7176 {
|
|
|
7177 switch ( value )
|
|
|
7178 {
|
|
|
7179 case VertexInputRate::eVertex : return "Vertex";
|
|
|
7180 case VertexInputRate::eInstance: return "Instance";
|
|
|
7181 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7182 }
|
|
|
7183 }
|
|
|
7184
|
|
|
7185 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineColorBlendStateCreateFlagBits value )
|
|
|
7186 {
|
|
|
7187 switch ( value )
|
|
|
7188 {
|
|
|
7189 case PipelineColorBlendStateCreateFlagBits::eRasterizationOrderAttachmentAccessEXT: return "RasterizationOrderAttachmentAccessEXT";
|
|
|
7190 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7191 }
|
|
|
7192 }
|
|
|
7193
|
|
|
7194 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineDepthStencilStateCreateFlagBits value )
|
|
|
7195 {
|
|
|
7196 switch ( value )
|
|
|
7197 {
|
|
|
7198 case PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentDepthAccessEXT : return "RasterizationOrderAttachmentDepthAccessEXT";
|
|
|
7199 case PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentStencilAccessEXT: return "RasterizationOrderAttachmentStencilAccessEXT";
|
|
|
7200 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7201 }
|
|
|
7202 }
|
|
|
7203
|
|
|
7204 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineDynamicStateCreateFlagBits )
|
|
|
7205 {
|
|
|
7206 return "(void)";
|
|
|
7207 }
|
|
|
7208
|
|
|
7209 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineInputAssemblyStateCreateFlagBits )
|
|
|
7210 {
|
|
|
7211 return "(void)";
|
|
|
7212 }
|
|
|
7213
|
|
|
7214 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineMultisampleStateCreateFlagBits )
|
|
|
7215 {
|
|
|
7216 return "(void)";
|
|
|
7217 }
|
|
|
7218
|
|
|
7219 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRasterizationStateCreateFlagBits )
|
|
|
7220 {
|
|
|
7221 return "(void)";
|
|
|
7222 }
|
|
|
7223
|
|
|
7224 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineTessellationStateCreateFlagBits )
|
|
|
7225 {
|
|
|
7226 return "(void)";
|
|
|
7227 }
|
|
|
7228
|
|
|
7229 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineVertexInputStateCreateFlagBits )
|
|
|
7230 {
|
|
|
7231 return "(void)";
|
|
|
7232 }
|
|
|
7233
|
|
|
7234 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineViewportStateCreateFlagBits )
|
|
|
7235 {
|
|
|
7236 return "(void)";
|
|
|
7237 }
|
|
|
7238
|
|
|
7239 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AttachmentDescriptionFlagBits value )
|
|
|
7240 {
|
|
|
7241 switch ( value )
|
|
|
7242 {
|
|
|
7243 case AttachmentDescriptionFlagBits::eMayAlias : return "MayAlias";
|
|
|
7244 case AttachmentDescriptionFlagBits::eResolveSkipTransferFunctionKHR : return "ResolveSkipTransferFunctionKHR";
|
|
|
7245 case AttachmentDescriptionFlagBits::eResolveEnableTransferFunctionKHR: return "ResolveEnableTransferFunctionKHR";
|
|
|
7246 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7247 }
|
|
|
7248 }
|
|
|
7249
|
|
|
7250 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AttachmentLoadOp value )
|
|
|
7251 {
|
|
|
7252 switch ( value )
|
|
|
7253 {
|
|
|
7254 case AttachmentLoadOp::eLoad : return "Load";
|
|
|
7255 case AttachmentLoadOp::eClear : return "Clear";
|
|
|
7256 case AttachmentLoadOp::eDontCare: return "DontCare";
|
|
|
7257 case AttachmentLoadOp::eNone : return "None";
|
|
|
7258 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7259 }
|
|
|
7260 }
|
|
|
7261
|
|
|
7262 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AttachmentStoreOp value )
|
|
|
7263 {
|
|
|
7264 switch ( value )
|
|
|
7265 {
|
|
|
7266 case AttachmentStoreOp::eStore : return "Store";
|
|
|
7267 case AttachmentStoreOp::eDontCare: return "DontCare";
|
|
|
7268 case AttachmentStoreOp::eNone : return "None";
|
|
|
7269 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7270 }
|
|
|
7271 }
|
|
|
7272
|
|
|
7273 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FramebufferCreateFlagBits value )
|
|
|
7274 {
|
|
|
7275 switch ( value )
|
|
|
7276 {
|
|
|
7277 case FramebufferCreateFlagBits::eImageless: return "Imageless";
|
|
|
7278 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7279 }
|
|
|
7280 }
|
|
|
7281
|
|
|
7282 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( RenderPassCreateFlagBits value )
|
|
|
7283 {
|
|
|
7284 switch ( value )
|
|
|
7285 {
|
|
|
7286 case RenderPassCreateFlagBits::eTransformQCOM : return "TransformQCOM";
|
|
|
7287 case RenderPassCreateFlagBits::ePerLayerFragmentDensityVALVE: return "PerLayerFragmentDensityVALVE";
|
|
|
7288 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7289 }
|
|
|
7290 }
|
|
|
7291
|
|
|
7292 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SubpassDescriptionFlagBits value )
|
|
|
7293 {
|
|
|
7294 switch ( value )
|
|
|
7295 {
|
|
|
7296 case SubpassDescriptionFlagBits::ePerViewAttributesNVX : return "PerViewAttributesNVX";
|
|
|
7297 case SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX : return "PerViewPositionXOnlyNVX";
|
|
|
7298 case SubpassDescriptionFlagBits::eTileShadingApronQCOM : return "TileShadingApronQCOM";
|
|
|
7299 case SubpassDescriptionFlagBits::eRasterizationOrderAttachmentColorAccessEXT : return "RasterizationOrderAttachmentColorAccessEXT";
|
|
|
7300 case SubpassDescriptionFlagBits::eRasterizationOrderAttachmentDepthAccessEXT : return "RasterizationOrderAttachmentDepthAccessEXT";
|
|
|
7301 case SubpassDescriptionFlagBits::eRasterizationOrderAttachmentStencilAccessEXT: return "RasterizationOrderAttachmentStencilAccessEXT";
|
|
|
7302 case SubpassDescriptionFlagBits::eEnableLegacyDitheringEXT : return "EnableLegacyDitheringEXT";
|
|
|
7303 case SubpassDescriptionFlagBits::eFragmentRegionEXT : return "FragmentRegionEXT";
|
|
|
7304 case SubpassDescriptionFlagBits::eCustomResolveEXT : return "CustomResolveEXT";
|
|
|
7305 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7306 }
|
|
|
7307 }
|
|
|
7308
|
|
|
7309 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( StencilFaceFlagBits value )
|
|
|
7310 {
|
|
|
7311 switch ( value )
|
|
|
7312 {
|
|
|
7313 case StencilFaceFlagBits::eFront : return "Front";
|
|
|
7314 case StencilFaceFlagBits::eBack : return "Back";
|
|
|
7315 case StencilFaceFlagBits::eFrontAndBack: return "FrontAndBack";
|
|
|
7316 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7317 }
|
|
|
7318 }
|
|
|
7319
|
|
|
7320 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SubpassContents value )
|
|
|
7321 {
|
|
|
7322 switch ( value )
|
|
|
7323 {
|
|
|
7324 case SubpassContents::eInline : return "Inline";
|
|
|
7325 case SubpassContents::eSecondaryCommandBuffers : return "SecondaryCommandBuffers";
|
|
|
7326 case SubpassContents::eInlineAndSecondaryCommandBuffersKHR: return "InlineAndSecondaryCommandBuffersKHR";
|
|
|
7327 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7328 }
|
|
|
7329 }
|
|
|
7330
|
|
|
7331 //=== VK_VERSION_1_1 ===
|
|
|
7332
|
|
|
7333 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PeerMemoryFeatureFlagBits value )
|
|
|
7334 {
|
|
|
7335 switch ( value )
|
|
|
7336 {
|
|
|
7337 case PeerMemoryFeatureFlagBits::eCopySrc : return "CopySrc";
|
|
|
7338 case PeerMemoryFeatureFlagBits::eCopyDst : return "CopyDst";
|
|
|
7339 case PeerMemoryFeatureFlagBits::eGenericSrc: return "GenericSrc";
|
|
|
7340 case PeerMemoryFeatureFlagBits::eGenericDst: return "GenericDst";
|
|
|
7341 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7342 }
|
|
|
7343 }
|
|
|
7344
|
|
|
7345 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MemoryAllocateFlagBits value )
|
|
|
7346 {
|
|
|
7347 switch ( value )
|
|
|
7348 {
|
|
|
7349 case MemoryAllocateFlagBits::eDeviceMask : return "DeviceMask";
|
|
|
7350 case MemoryAllocateFlagBits::eDeviceAddress : return "DeviceAddress";
|
|
|
7351 case MemoryAllocateFlagBits::eDeviceAddressCaptureReplay: return "DeviceAddressCaptureReplay";
|
|
|
7352 case MemoryAllocateFlagBits::eZeroInitializeEXT : return "ZeroInitializeEXT";
|
|
|
7353 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7354 }
|
|
|
7355 }
|
|
|
7356
|
|
|
7357 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CommandPoolTrimFlagBits )
|
|
|
7358 {
|
|
|
7359 return "(void)";
|
|
|
7360 }
|
|
|
7361
|
|
|
7362 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ExternalMemoryHandleTypeFlagBits value )
|
|
|
7363 {
|
|
|
7364 switch ( value )
|
|
|
7365 {
|
|
|
7366 case ExternalMemoryHandleTypeFlagBits::eOpaqueFd : return "OpaqueFd";
|
|
|
7367 case ExternalMemoryHandleTypeFlagBits::eOpaqueWin32 : return "OpaqueWin32";
|
|
|
7368 case ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt : return "OpaqueWin32Kmt";
|
|
|
7369 case ExternalMemoryHandleTypeFlagBits::eD3D11Texture : return "D3D11Texture";
|
|
|
7370 case ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt: return "D3D11TextureKmt";
|
|
|
7371 case ExternalMemoryHandleTypeFlagBits::eD3D12Heap : return "D3D12Heap";
|
|
|
7372 case ExternalMemoryHandleTypeFlagBits::eD3D12Resource : return "D3D12Resource";
|
|
|
7373 case ExternalMemoryHandleTypeFlagBits::eDmaBufEXT : return "DmaBufEXT";
|
|
|
7374 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
|
7375 case ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID: return "AndroidHardwareBufferANDROID";
|
|
|
7376 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
7377 case ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT : return "HostAllocationEXT";
|
|
|
7378 case ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT: return "HostMappedForeignMemoryEXT";
|
|
|
7379 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
7380 case ExternalMemoryHandleTypeFlagBits::eZirconVmoFUCHSIA: return "ZirconVmoFUCHSIA";
|
|
|
7381 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
7382 case ExternalMemoryHandleTypeFlagBits::eRdmaAddressNV: return "RdmaAddressNV";
|
|
|
7383 #if defined( VK_USE_PLATFORM_OHOS )
|
|
|
7384 case ExternalMemoryHandleTypeFlagBits::eOhNativeBufferOHOS: return "OhNativeBufferOHOS";
|
|
|
7385 #endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
7386 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
|
7387 case ExternalMemoryHandleTypeFlagBits::eScreenBufferQNX: return "ScreenBufferQNX";
|
|
|
7388 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
|
7389 #if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
7390 case ExternalMemoryHandleTypeFlagBits::eMtlbufferEXT : return "MtlbufferEXT";
|
|
|
7391 case ExternalMemoryHandleTypeFlagBits::eMtltextureEXT: return "MtltextureEXT";
|
|
|
7392 case ExternalMemoryHandleTypeFlagBits::eMtlheapEXT : return "MtlheapEXT";
|
|
|
7393 #endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
7394 default: return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7395 }
|
|
|
7396 }
|
|
|
7397
|
|
|
7398 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ExternalMemoryFeatureFlagBits value )
|
|
|
7399 {
|
|
|
7400 switch ( value )
|
|
|
7401 {
|
|
|
7402 case ExternalMemoryFeatureFlagBits::eDedicatedOnly: return "DedicatedOnly";
|
|
|
7403 case ExternalMemoryFeatureFlagBits::eExportable : return "Exportable";
|
|
|
7404 case ExternalMemoryFeatureFlagBits::eImportable : return "Importable";
|
|
|
7405 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7406 }
|
|
|
7407 }
|
|
|
7408
|
|
|
7409 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ExternalFenceHandleTypeFlagBits value )
|
|
|
7410 {
|
|
|
7411 switch ( value )
|
|
|
7412 {
|
|
|
7413 case ExternalFenceHandleTypeFlagBits::eOpaqueFd : return "OpaqueFd";
|
|
|
7414 case ExternalFenceHandleTypeFlagBits::eOpaqueWin32 : return "OpaqueWin32";
|
|
|
7415 case ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt: return "OpaqueWin32Kmt";
|
|
|
7416 case ExternalFenceHandleTypeFlagBits::eSyncFd : return "SyncFd";
|
|
|
7417 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7418 }
|
|
|
7419 }
|
|
|
7420
|
|
|
7421 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ExternalFenceFeatureFlagBits value )
|
|
|
7422 {
|
|
|
7423 switch ( value )
|
|
|
7424 {
|
|
|
7425 case ExternalFenceFeatureFlagBits::eExportable: return "Exportable";
|
|
|
7426 case ExternalFenceFeatureFlagBits::eImportable: return "Importable";
|
|
|
7427 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7428 }
|
|
|
7429 }
|
|
|
7430
|
|
|
7431 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FenceImportFlagBits value )
|
|
|
7432 {
|
|
|
7433 switch ( value )
|
|
|
7434 {
|
|
|
7435 case FenceImportFlagBits::eTemporary: return "Temporary";
|
|
|
7436 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7437 }
|
|
|
7438 }
|
|
|
7439
|
|
|
7440 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SemaphoreImportFlagBits value )
|
|
|
7441 {
|
|
|
7442 switch ( value )
|
|
|
7443 {
|
|
|
7444 case SemaphoreImportFlagBits::eTemporary: return "Temporary";
|
|
|
7445 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7446 }
|
|
|
7447 }
|
|
|
7448
|
|
|
7449 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ExternalSemaphoreHandleTypeFlagBits value )
|
|
|
7450 {
|
|
|
7451 switch ( value )
|
|
|
7452 {
|
|
|
7453 case ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd : return "OpaqueFd";
|
|
|
7454 case ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32 : return "OpaqueWin32";
|
|
|
7455 case ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt: return "OpaqueWin32Kmt";
|
|
|
7456 case ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence : return "D3D12Fence";
|
|
|
7457 case ExternalSemaphoreHandleTypeFlagBits::eSyncFd : return "SyncFd";
|
|
|
7458 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
7459 case ExternalSemaphoreHandleTypeFlagBits::eZirconEventFUCHSIA: return "ZirconEventFUCHSIA";
|
|
|
7460 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
7461 default: return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7462 }
|
|
|
7463 }
|
|
|
7464
|
|
|
7465 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ExternalSemaphoreFeatureFlagBits value )
|
|
|
7466 {
|
|
|
7467 switch ( value )
|
|
|
7468 {
|
|
|
7469 case ExternalSemaphoreFeatureFlagBits::eExportable: return "Exportable";
|
|
|
7470 case ExternalSemaphoreFeatureFlagBits::eImportable: return "Importable";
|
|
|
7471 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7472 }
|
|
|
7473 }
|
|
|
7474
|
|
|
7475 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SubgroupFeatureFlagBits value )
|
|
|
7476 {
|
|
|
7477 switch ( value )
|
|
|
7478 {
|
|
|
7479 case SubgroupFeatureFlagBits::eBasic : return "Basic";
|
|
|
7480 case SubgroupFeatureFlagBits::eVote : return "Vote";
|
|
|
7481 case SubgroupFeatureFlagBits::eArithmetic : return "Arithmetic";
|
|
|
7482 case SubgroupFeatureFlagBits::eBallot : return "Ballot";
|
|
|
7483 case SubgroupFeatureFlagBits::eShuffle : return "Shuffle";
|
|
|
7484 case SubgroupFeatureFlagBits::eShuffleRelative: return "ShuffleRelative";
|
|
|
7485 case SubgroupFeatureFlagBits::eClustered : return "Clustered";
|
|
|
7486 case SubgroupFeatureFlagBits::eQuad : return "Quad";
|
|
|
7487 case SubgroupFeatureFlagBits::eRotate : return "Rotate";
|
|
|
7488 case SubgroupFeatureFlagBits::eRotateClustered: return "RotateClustered";
|
|
|
7489 case SubgroupFeatureFlagBits::ePartitionedNV : return "PartitionedNV";
|
|
|
7490 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7491 }
|
|
|
7492 }
|
|
|
7493
|
|
|
7494 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorUpdateTemplateType value )
|
|
|
7495 {
|
|
|
7496 switch ( value )
|
|
|
7497 {
|
|
|
7498 case DescriptorUpdateTemplateType::eDescriptorSet : return "DescriptorSet";
|
|
|
7499 case DescriptorUpdateTemplateType::ePushDescriptors: return "PushDescriptors";
|
|
|
7500 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7501 }
|
|
|
7502 }
|
|
|
7503
|
|
|
7504 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorUpdateTemplateCreateFlagBits )
|
|
|
7505 {
|
|
|
7506 return "(void)";
|
|
|
7507 }
|
|
|
7508
|
|
|
7509 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SamplerYcbcrModelConversion value )
|
|
|
7510 {
|
|
|
7511 switch ( value )
|
|
|
7512 {
|
|
|
7513 case SamplerYcbcrModelConversion::eRgbIdentity : return "RgbIdentity";
|
|
|
7514 case SamplerYcbcrModelConversion::eYcbcrIdentity: return "YcbcrIdentity";
|
|
|
7515 case SamplerYcbcrModelConversion::eYcbcr709 : return "Ycbcr709";
|
|
|
7516 case SamplerYcbcrModelConversion::eYcbcr601 : return "Ycbcr601";
|
|
|
7517 case SamplerYcbcrModelConversion::eYcbcr2020 : return "Ycbcr2020";
|
|
|
7518 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7519 }
|
|
|
7520 }
|
|
|
7521
|
|
|
7522 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SamplerYcbcrRange value )
|
|
|
7523 {
|
|
|
7524 switch ( value )
|
|
|
7525 {
|
|
|
7526 case SamplerYcbcrRange::eItuFull : return "ItuFull";
|
|
|
7527 case SamplerYcbcrRange::eItuNarrow: return "ItuNarrow";
|
|
|
7528 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7529 }
|
|
|
7530 }
|
|
|
7531
|
|
|
7532 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ChromaLocation value )
|
|
|
7533 {
|
|
|
7534 switch ( value )
|
|
|
7535 {
|
|
|
7536 case ChromaLocation::eCositedEven: return "CositedEven";
|
|
|
7537 case ChromaLocation::eMidpoint : return "Midpoint";
|
|
|
7538 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7539 }
|
|
|
7540 }
|
|
|
7541
|
|
|
7542 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PointClippingBehavior value )
|
|
|
7543 {
|
|
|
7544 switch ( value )
|
|
|
7545 {
|
|
|
7546 case PointClippingBehavior::eAllClipPlanes : return "AllClipPlanes";
|
|
|
7547 case PointClippingBehavior::eUserClipPlanesOnly: return "UserClipPlanesOnly";
|
|
|
7548 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7549 }
|
|
|
7550 }
|
|
|
7551
|
|
|
7552 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( TessellationDomainOrigin value )
|
|
|
7553 {
|
|
|
7554 switch ( value )
|
|
|
7555 {
|
|
|
7556 case TessellationDomainOrigin::eUpperLeft: return "UpperLeft";
|
|
|
7557 case TessellationDomainOrigin::eLowerLeft: return "LowerLeft";
|
|
|
7558 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7559 }
|
|
|
7560 }
|
|
|
7561
|
|
|
7562 //=== VK_VERSION_1_2 ===
|
|
|
7563
|
|
|
7564 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DriverId value )
|
|
|
7565 {
|
|
|
7566 switch ( value )
|
|
|
7567 {
|
|
|
7568 case DriverId::eAmdProprietary : return "AmdProprietary";
|
|
|
7569 case DriverId::eAmdOpenSource : return "AmdOpenSource";
|
|
|
7570 case DriverId::eMesaRadv : return "MesaRadv";
|
|
|
7571 case DriverId::eNvidiaProprietary : return "NvidiaProprietary";
|
|
|
7572 case DriverId::eIntelProprietaryWindows : return "IntelProprietaryWindows";
|
|
|
7573 case DriverId::eIntelOpenSourceMESA : return "IntelOpenSourceMESA";
|
|
|
7574 case DriverId::eImaginationProprietary : return "ImaginationProprietary";
|
|
|
7575 case DriverId::eQualcommProprietary : return "QualcommProprietary";
|
|
|
7576 case DriverId::eArmProprietary : return "ArmProprietary";
|
|
|
7577 case DriverId::eGoogleSwiftshader : return "GoogleSwiftshader";
|
|
|
7578 case DriverId::eGgpProprietary : return "GgpProprietary";
|
|
|
7579 case DriverId::eBroadcomProprietary : return "BroadcomProprietary";
|
|
|
7580 case DriverId::eMesaLlvmpipe : return "MesaLlvmpipe";
|
|
|
7581 case DriverId::eMoltenvk : return "Moltenvk";
|
|
|
7582 case DriverId::eCoreaviProprietary : return "CoreaviProprietary";
|
|
|
7583 case DriverId::eJuiceProprietary : return "JuiceProprietary";
|
|
|
7584 case DriverId::eVerisiliconProprietary : return "VerisiliconProprietary";
|
|
|
7585 case DriverId::eMesaTurnip : return "MesaTurnip";
|
|
|
7586 case DriverId::eMesaV3Dv : return "MesaV3Dv";
|
|
|
7587 case DriverId::eMesaPanvk : return "MesaPanvk";
|
|
|
7588 case DriverId::eSamsungProprietary : return "SamsungProprietary";
|
|
|
7589 case DriverId::eMesaVenus : return "MesaVenus";
|
|
|
7590 case DriverId::eMesaDozen : return "MesaDozen";
|
|
|
7591 case DriverId::eMesaNvk : return "MesaNvk";
|
|
|
7592 case DriverId::eImaginationOpenSourceMESA: return "ImaginationOpenSourceMESA";
|
|
|
7593 case DriverId::eMesaHoneykrisp : return "MesaHoneykrisp";
|
|
|
7594 case DriverId::eVulkanScEmulationOnVulkan: return "VulkanScEmulationOnVulkan";
|
|
|
7595 case DriverId::eMesaKosmickrisp : return "MesaKosmickrisp";
|
|
|
7596 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7597 }
|
|
|
7598 }
|
|
|
7599
|
|
|
7600 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SemaphoreType value )
|
|
|
7601 {
|
|
|
7602 switch ( value )
|
|
|
7603 {
|
|
|
7604 case SemaphoreType::eBinary : return "Binary";
|
|
|
7605 case SemaphoreType::eTimeline: return "Timeline";
|
|
|
7606 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7607 }
|
|
|
7608 }
|
|
|
7609
|
|
|
7610 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SemaphoreWaitFlagBits value )
|
|
|
7611 {
|
|
|
7612 switch ( value )
|
|
|
7613 {
|
|
|
7614 case SemaphoreWaitFlagBits::eAny: return "Any";
|
|
|
7615 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7616 }
|
|
|
7617 }
|
|
|
7618
|
|
|
7619 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderFloatControlsIndependence value )
|
|
|
7620 {
|
|
|
7621 switch ( value )
|
|
|
7622 {
|
|
|
7623 case ShaderFloatControlsIndependence::e32BitOnly: return "32BitOnly";
|
|
|
7624 case ShaderFloatControlsIndependence::eAll : return "All";
|
|
|
7625 case ShaderFloatControlsIndependence::eNone : return "None";
|
|
|
7626 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7627 }
|
|
|
7628 }
|
|
|
7629
|
|
|
7630 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorBindingFlagBits value )
|
|
|
7631 {
|
|
|
7632 switch ( value )
|
|
|
7633 {
|
|
|
7634 case DescriptorBindingFlagBits::eUpdateAfterBind : return "UpdateAfterBind";
|
|
|
7635 case DescriptorBindingFlagBits::eUpdateUnusedWhilePending: return "UpdateUnusedWhilePending";
|
|
|
7636 case DescriptorBindingFlagBits::ePartiallyBound : return "PartiallyBound";
|
|
|
7637 case DescriptorBindingFlagBits::eVariableDescriptorCount : return "VariableDescriptorCount";
|
|
|
7638 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7639 }
|
|
|
7640 }
|
|
|
7641
|
|
|
7642 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SamplerReductionMode value )
|
|
|
7643 {
|
|
|
7644 switch ( value )
|
|
|
7645 {
|
|
|
7646 case SamplerReductionMode::eWeightedAverage : return "WeightedAverage";
|
|
|
7647 case SamplerReductionMode::eMin : return "Min";
|
|
|
7648 case SamplerReductionMode::eMax : return "Max";
|
|
|
7649 case SamplerReductionMode::eWeightedAverageRangeclampQCOM: return "WeightedAverageRangeclampQCOM";
|
|
|
7650 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7651 }
|
|
|
7652 }
|
|
|
7653
|
|
|
7654 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ResolveModeFlagBits value )
|
|
|
7655 {
|
|
|
7656 switch ( value )
|
|
|
7657 {
|
|
|
7658 case ResolveModeFlagBits::eNone : return "None";
|
|
|
7659 case ResolveModeFlagBits::eSampleZero: return "SampleZero";
|
|
|
7660 case ResolveModeFlagBits::eAverage : return "Average";
|
|
|
7661 case ResolveModeFlagBits::eMin : return "Min";
|
|
|
7662 case ResolveModeFlagBits::eMax : return "Max";
|
|
|
7663 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
|
7664 case ResolveModeFlagBits::eExternalFormatDownsampleANDROID: return "ExternalFormatDownsampleANDROID";
|
|
|
7665 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
7666 case ResolveModeFlagBits::eCustomEXT: return "CustomEXT";
|
|
|
7667 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7668 }
|
|
|
7669 }
|
|
|
7670
|
|
|
7671 //=== VK_VERSION_1_3 ===
|
|
|
7672
|
|
|
7673 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ToolPurposeFlagBits value )
|
|
|
7674 {
|
|
|
7675 switch ( value )
|
|
|
7676 {
|
|
|
7677 case ToolPurposeFlagBits::eValidation : return "Validation";
|
|
|
7678 case ToolPurposeFlagBits::eProfiling : return "Profiling";
|
|
|
7679 case ToolPurposeFlagBits::eTracing : return "Tracing";
|
|
|
7680 case ToolPurposeFlagBits::eAdditionalFeatures: return "AdditionalFeatures";
|
|
|
7681 case ToolPurposeFlagBits::eModifyingFeatures : return "ModifyingFeatures";
|
|
|
7682 case ToolPurposeFlagBits::eDebugReportingEXT : return "DebugReportingEXT";
|
|
|
7683 case ToolPurposeFlagBits::eDebugMarkersEXT : return "DebugMarkersEXT";
|
|
|
7684 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7685 }
|
|
|
7686 }
|
|
|
7687
|
|
|
7688 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PrivateDataSlotCreateFlagBits )
|
|
|
7689 {
|
|
|
7690 return "(void)";
|
|
|
7691 }
|
|
|
7692
|
|
|
7693 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineStageFlagBits2 value )
|
|
|
7694 {
|
|
|
7695 switch ( value )
|
|
|
7696 {
|
|
|
7697 case PipelineStageFlagBits2::eNone : return "None";
|
|
|
7698 case PipelineStageFlagBits2::eTopOfPipe : return "TopOfPipe";
|
|
|
7699 case PipelineStageFlagBits2::eDrawIndirect : return "DrawIndirect";
|
|
|
7700 case PipelineStageFlagBits2::eVertexInput : return "VertexInput";
|
|
|
7701 case PipelineStageFlagBits2::eVertexShader : return "VertexShader";
|
|
|
7702 case PipelineStageFlagBits2::eTessellationControlShader : return "TessellationControlShader";
|
|
|
7703 case PipelineStageFlagBits2::eTessellationEvaluationShader : return "TessellationEvaluationShader";
|
|
|
7704 case PipelineStageFlagBits2::eGeometryShader : return "GeometryShader";
|
|
|
7705 case PipelineStageFlagBits2::eFragmentShader : return "FragmentShader";
|
|
|
7706 case PipelineStageFlagBits2::eEarlyFragmentTests : return "EarlyFragmentTests";
|
|
|
7707 case PipelineStageFlagBits2::eLateFragmentTests : return "LateFragmentTests";
|
|
|
7708 case PipelineStageFlagBits2::eColorAttachmentOutput : return "ColorAttachmentOutput";
|
|
|
7709 case PipelineStageFlagBits2::eComputeShader : return "ComputeShader";
|
|
|
7710 case PipelineStageFlagBits2::eAllTransfer : return "AllTransfer";
|
|
|
7711 case PipelineStageFlagBits2::eBottomOfPipe : return "BottomOfPipe";
|
|
|
7712 case PipelineStageFlagBits2::eHost : return "Host";
|
|
|
7713 case PipelineStageFlagBits2::eAllGraphics : return "AllGraphics";
|
|
|
7714 case PipelineStageFlagBits2::eAllCommands : return "AllCommands";
|
|
|
7715 case PipelineStageFlagBits2::eCopy : return "Copy";
|
|
|
7716 case PipelineStageFlagBits2::eResolve : return "Resolve";
|
|
|
7717 case PipelineStageFlagBits2::eBlit : return "Blit";
|
|
|
7718 case PipelineStageFlagBits2::eClear : return "Clear";
|
|
|
7719 case PipelineStageFlagBits2::eIndexInput : return "IndexInput";
|
|
|
7720 case PipelineStageFlagBits2::eVertexAttributeInput : return "VertexAttributeInput";
|
|
|
7721 case PipelineStageFlagBits2::ePreRasterizationShaders : return "PreRasterizationShaders";
|
|
|
7722 case PipelineStageFlagBits2::eVideoDecodeKHR : return "VideoDecodeKHR";
|
|
|
7723 case PipelineStageFlagBits2::eVideoEncodeKHR : return "VideoEncodeKHR";
|
|
|
7724 case PipelineStageFlagBits2::eTransformFeedbackEXT : return "TransformFeedbackEXT";
|
|
|
7725 case PipelineStageFlagBits2::eConditionalRenderingEXT : return "ConditionalRenderingEXT";
|
|
|
7726 case PipelineStageFlagBits2::eCommandPreprocessEXT : return "CommandPreprocessEXT";
|
|
|
7727 case PipelineStageFlagBits2::eFragmentShadingRateAttachmentKHR: return "FragmentShadingRateAttachmentKHR";
|
|
|
7728 case PipelineStageFlagBits2::eAccelerationStructureBuildKHR : return "AccelerationStructureBuildKHR";
|
|
|
7729 case PipelineStageFlagBits2::eRayTracingShaderKHR : return "RayTracingShaderKHR";
|
|
|
7730 case PipelineStageFlagBits2::eFragmentDensityProcessEXT : return "FragmentDensityProcessEXT";
|
|
|
7731 case PipelineStageFlagBits2::eTaskShaderEXT : return "TaskShaderEXT";
|
|
|
7732 case PipelineStageFlagBits2::eMeshShaderEXT : return "MeshShaderEXT";
|
|
|
7733 case PipelineStageFlagBits2::eSubpassShaderHUAWEI : return "SubpassShaderHUAWEI";
|
|
|
7734 case PipelineStageFlagBits2::eInvocationMaskHUAWEI : return "InvocationMaskHUAWEI";
|
|
|
7735 case PipelineStageFlagBits2::eAccelerationStructureCopyKHR : return "AccelerationStructureCopyKHR";
|
|
|
7736 case PipelineStageFlagBits2::eMicromapBuildEXT : return "MicromapBuildEXT";
|
|
|
7737 case PipelineStageFlagBits2::eClusterCullingShaderHUAWEI : return "ClusterCullingShaderHUAWEI";
|
|
|
7738 case PipelineStageFlagBits2::eOpticalFlowNV : return "OpticalFlowNV";
|
|
|
7739 case PipelineStageFlagBits2::eConvertCooperativeVectorMatrixNV: return "ConvertCooperativeVectorMatrixNV";
|
|
|
7740 case PipelineStageFlagBits2::eDataGraphARM : return "DataGraphARM";
|
|
|
7741 case PipelineStageFlagBits2::eCopyIndirectKHR : return "CopyIndirectKHR";
|
|
|
7742 case PipelineStageFlagBits2::eMemoryDecompressionEXT : return "MemoryDecompressionEXT";
|
|
|
7743 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7744 }
|
|
|
7745 }
|
|
|
7746
|
|
|
7747 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccessFlagBits2 value )
|
|
|
7748 {
|
|
|
7749 switch ( value )
|
|
|
7750 {
|
|
|
7751 case AccessFlagBits2::eNone : return "None";
|
|
|
7752 case AccessFlagBits2::eIndirectCommandRead : return "IndirectCommandRead";
|
|
|
7753 case AccessFlagBits2::eIndexRead : return "IndexRead";
|
|
|
7754 case AccessFlagBits2::eVertexAttributeRead : return "VertexAttributeRead";
|
|
|
7755 case AccessFlagBits2::eUniformRead : return "UniformRead";
|
|
|
7756 case AccessFlagBits2::eInputAttachmentRead : return "InputAttachmentRead";
|
|
|
7757 case AccessFlagBits2::eShaderRead : return "ShaderRead";
|
|
|
7758 case AccessFlagBits2::eShaderWrite : return "ShaderWrite";
|
|
|
7759 case AccessFlagBits2::eColorAttachmentRead : return "ColorAttachmentRead";
|
|
|
7760 case AccessFlagBits2::eColorAttachmentWrite : return "ColorAttachmentWrite";
|
|
|
7761 case AccessFlagBits2::eDepthStencilAttachmentRead : return "DepthStencilAttachmentRead";
|
|
|
7762 case AccessFlagBits2::eDepthStencilAttachmentWrite : return "DepthStencilAttachmentWrite";
|
|
|
7763 case AccessFlagBits2::eTransferRead : return "TransferRead";
|
|
|
7764 case AccessFlagBits2::eTransferWrite : return "TransferWrite";
|
|
|
7765 case AccessFlagBits2::eHostRead : return "HostRead";
|
|
|
7766 case AccessFlagBits2::eHostWrite : return "HostWrite";
|
|
|
7767 case AccessFlagBits2::eMemoryRead : return "MemoryRead";
|
|
|
7768 case AccessFlagBits2::eMemoryWrite : return "MemoryWrite";
|
|
|
7769 case AccessFlagBits2::eShaderSampledRead : return "ShaderSampledRead";
|
|
|
7770 case AccessFlagBits2::eShaderStorageRead : return "ShaderStorageRead";
|
|
|
7771 case AccessFlagBits2::eShaderStorageWrite : return "ShaderStorageWrite";
|
|
|
7772 case AccessFlagBits2::eVideoDecodeReadKHR : return "VideoDecodeReadKHR";
|
|
|
7773 case AccessFlagBits2::eVideoDecodeWriteKHR : return "VideoDecodeWriteKHR";
|
|
|
7774 case AccessFlagBits2::eVideoEncodeReadKHR : return "VideoEncodeReadKHR";
|
|
|
7775 case AccessFlagBits2::eVideoEncodeWriteKHR : return "VideoEncodeWriteKHR";
|
|
|
7776 case AccessFlagBits2::eShaderTileAttachmentReadQCOM : return "ShaderTileAttachmentReadQCOM";
|
|
|
7777 case AccessFlagBits2::eShaderTileAttachmentWriteQCOM : return "ShaderTileAttachmentWriteQCOM";
|
|
|
7778 case AccessFlagBits2::eTransformFeedbackWriteEXT : return "TransformFeedbackWriteEXT";
|
|
|
7779 case AccessFlagBits2::eTransformFeedbackCounterReadEXT : return "TransformFeedbackCounterReadEXT";
|
|
|
7780 case AccessFlagBits2::eTransformFeedbackCounterWriteEXT : return "TransformFeedbackCounterWriteEXT";
|
|
|
7781 case AccessFlagBits2::eConditionalRenderingReadEXT : return "ConditionalRenderingReadEXT";
|
|
|
7782 case AccessFlagBits2::eCommandPreprocessReadEXT : return "CommandPreprocessReadEXT";
|
|
|
7783 case AccessFlagBits2::eCommandPreprocessWriteEXT : return "CommandPreprocessWriteEXT";
|
|
|
7784 case AccessFlagBits2::eFragmentShadingRateAttachmentReadKHR: return "FragmentShadingRateAttachmentReadKHR";
|
|
|
7785 case AccessFlagBits2::eAccelerationStructureReadKHR : return "AccelerationStructureReadKHR";
|
|
|
7786 case AccessFlagBits2::eAccelerationStructureWriteKHR : return "AccelerationStructureWriteKHR";
|
|
|
7787 case AccessFlagBits2::eFragmentDensityMapReadEXT : return "FragmentDensityMapReadEXT";
|
|
|
7788 case AccessFlagBits2::eColorAttachmentReadNoncoherentEXT : return "ColorAttachmentReadNoncoherentEXT";
|
|
|
7789 case AccessFlagBits2::eDescriptorBufferReadEXT : return "DescriptorBufferReadEXT";
|
|
|
7790 case AccessFlagBits2::eInvocationMaskReadHUAWEI : return "InvocationMaskReadHUAWEI";
|
|
|
7791 case AccessFlagBits2::eShaderBindingTableReadKHR : return "ShaderBindingTableReadKHR";
|
|
|
7792 case AccessFlagBits2::eMicromapReadEXT : return "MicromapReadEXT";
|
|
|
7793 case AccessFlagBits2::eMicromapWriteEXT : return "MicromapWriteEXT";
|
|
|
7794 case AccessFlagBits2::eOpticalFlowReadNV : return "OpticalFlowReadNV";
|
|
|
7795 case AccessFlagBits2::eOpticalFlowWriteNV : return "OpticalFlowWriteNV";
|
|
|
7796 case AccessFlagBits2::eDataGraphReadARM : return "DataGraphReadARM";
|
|
|
7797 case AccessFlagBits2::eDataGraphWriteARM : return "DataGraphWriteARM";
|
|
|
7798 case AccessFlagBits2::eMemoryDecompressionReadEXT : return "MemoryDecompressionReadEXT";
|
|
|
7799 case AccessFlagBits2::eMemoryDecompressionWriteEXT : return "MemoryDecompressionWriteEXT";
|
|
|
7800 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7801 }
|
|
|
7802 }
|
|
|
7803
|
|
|
7804 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SubmitFlagBits value )
|
|
|
7805 {
|
|
|
7806 switch ( value )
|
|
|
7807 {
|
|
|
7808 case SubmitFlagBits::eProtected: return "Protected";
|
|
|
7809 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7810 }
|
|
|
7811 }
|
|
|
7812
|
|
|
7813 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FormatFeatureFlagBits2 value )
|
|
|
7814 {
|
|
|
7815 switch ( value )
|
|
|
7816 {
|
|
|
7817 case FormatFeatureFlagBits2::eSampledImage : return "SampledImage";
|
|
|
7818 case FormatFeatureFlagBits2::eStorageImage : return "StorageImage";
|
|
|
7819 case FormatFeatureFlagBits2::eStorageImageAtomic : return "StorageImageAtomic";
|
|
|
7820 case FormatFeatureFlagBits2::eUniformTexelBuffer : return "UniformTexelBuffer";
|
|
|
7821 case FormatFeatureFlagBits2::eStorageTexelBuffer : return "StorageTexelBuffer";
|
|
|
7822 case FormatFeatureFlagBits2::eStorageTexelBufferAtomic : return "StorageTexelBufferAtomic";
|
|
|
7823 case FormatFeatureFlagBits2::eVertexBuffer : return "VertexBuffer";
|
|
|
7824 case FormatFeatureFlagBits2::eColorAttachment : return "ColorAttachment";
|
|
|
7825 case FormatFeatureFlagBits2::eColorAttachmentBlend : return "ColorAttachmentBlend";
|
|
|
7826 case FormatFeatureFlagBits2::eDepthStencilAttachment : return "DepthStencilAttachment";
|
|
|
7827 case FormatFeatureFlagBits2::eBlitSrc : return "BlitSrc";
|
|
|
7828 case FormatFeatureFlagBits2::eBlitDst : return "BlitDst";
|
|
|
7829 case FormatFeatureFlagBits2::eSampledImageFilterLinear : return "SampledImageFilterLinear";
|
|
|
7830 case FormatFeatureFlagBits2::eTransferSrc : return "TransferSrc";
|
|
|
7831 case FormatFeatureFlagBits2::eTransferDst : return "TransferDst";
|
|
|
7832 case FormatFeatureFlagBits2::eSampledImageFilterMinmax : return "SampledImageFilterMinmax";
|
|
|
7833 case FormatFeatureFlagBits2::eMidpointChromaSamples : return "MidpointChromaSamples";
|
|
|
7834 case FormatFeatureFlagBits2::eSampledImageYcbcrConversionLinearFilter : return "SampledImageYcbcrConversionLinearFilter";
|
|
|
7835 case FormatFeatureFlagBits2::eSampledImageYcbcrConversionSeparateReconstructionFilter: return "SampledImageYcbcrConversionSeparateReconstructionFilter";
|
|
|
7836 case FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicit: return "SampledImageYcbcrConversionChromaReconstructionExplicit";
|
|
|
7837 case FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable:
|
|
|
7838 return "SampledImageYcbcrConversionChromaReconstructionExplicitForceable";
|
|
|
7839 case FormatFeatureFlagBits2::eDisjoint : return "Disjoint";
|
|
|
7840 case FormatFeatureFlagBits2::eCositedChromaSamples : return "CositedChromaSamples";
|
|
|
7841 case FormatFeatureFlagBits2::eStorageReadWithoutFormat : return "StorageReadWithoutFormat";
|
|
|
7842 case FormatFeatureFlagBits2::eStorageWriteWithoutFormat : return "StorageWriteWithoutFormat";
|
|
|
7843 case FormatFeatureFlagBits2::eSampledImageDepthComparison : return "SampledImageDepthComparison";
|
|
|
7844 case FormatFeatureFlagBits2::eSampledImageFilterCubic : return "SampledImageFilterCubic";
|
|
|
7845 case FormatFeatureFlagBits2::eHostImageTransfer : return "HostImageTransfer";
|
|
|
7846 case FormatFeatureFlagBits2::eVideoDecodeOutputKHR : return "VideoDecodeOutputKHR";
|
|
|
7847 case FormatFeatureFlagBits2::eVideoDecodeDpbKHR : return "VideoDecodeDpbKHR";
|
|
|
7848 case FormatFeatureFlagBits2::eAccelerationStructureVertexBufferKHR: return "AccelerationStructureVertexBufferKHR";
|
|
|
7849 case FormatFeatureFlagBits2::eFragmentDensityMapEXT : return "FragmentDensityMapEXT";
|
|
|
7850 case FormatFeatureFlagBits2::eFragmentShadingRateAttachmentKHR : return "FragmentShadingRateAttachmentKHR";
|
|
|
7851 case FormatFeatureFlagBits2::eVideoEncodeInputKHR : return "VideoEncodeInputKHR";
|
|
|
7852 case FormatFeatureFlagBits2::eVideoEncodeDpbKHR : return "VideoEncodeDpbKHR";
|
|
|
7853 case FormatFeatureFlagBits2::eAccelerationStructureRadiusBufferNV : return "AccelerationStructureRadiusBufferNV";
|
|
|
7854 case FormatFeatureFlagBits2::eLinearColorAttachmentNV : return "LinearColorAttachmentNV";
|
|
|
7855 case FormatFeatureFlagBits2::eWeightImageQCOM : return "WeightImageQCOM";
|
|
|
7856 case FormatFeatureFlagBits2::eWeightSampledImageQCOM : return "WeightSampledImageQCOM";
|
|
|
7857 case FormatFeatureFlagBits2::eBlockMatchingQCOM : return "BlockMatchingQCOM";
|
|
|
7858 case FormatFeatureFlagBits2::eBoxFilterSampledQCOM : return "BoxFilterSampledQCOM";
|
|
|
7859 case FormatFeatureFlagBits2::eTensorShaderARM : return "TensorShaderARM";
|
|
|
7860 case FormatFeatureFlagBits2::eTensorImageAliasingARM : return "TensorImageAliasingARM";
|
|
|
7861 case FormatFeatureFlagBits2::eOpticalFlowImageNV : return "OpticalFlowImageNV";
|
|
|
7862 case FormatFeatureFlagBits2::eOpticalFlowVectorNV : return "OpticalFlowVectorNV";
|
|
|
7863 case FormatFeatureFlagBits2::eOpticalFlowCostNV : return "OpticalFlowCostNV";
|
|
|
7864 case FormatFeatureFlagBits2::eTensorDataGraphARM : return "TensorDataGraphARM";
|
|
|
7865 case FormatFeatureFlagBits2::eCopyImageIndirectDstKHR : return "CopyImageIndirectDstKHR";
|
|
|
7866 case FormatFeatureFlagBits2::eVideoEncodeQuantizationDeltaMapKHR : return "VideoEncodeQuantizationDeltaMapKHR";
|
|
|
7867 case FormatFeatureFlagBits2::eVideoEncodeEmphasisMapKHR : return "VideoEncodeEmphasisMapKHR";
|
|
|
7868 case FormatFeatureFlagBits2::eDepthCopyOnComputeQueueKHR : return "DepthCopyOnComputeQueueKHR";
|
|
|
7869 case FormatFeatureFlagBits2::eDepthCopyOnTransferQueueKHR : return "DepthCopyOnTransferQueueKHR";
|
|
|
7870 case FormatFeatureFlagBits2::eStencilCopyOnComputeQueueKHR : return "StencilCopyOnComputeQueueKHR";
|
|
|
7871 case FormatFeatureFlagBits2::eStencilCopyOnTransferQueueKHR : return "StencilCopyOnTransferQueueKHR";
|
|
|
7872 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7873 }
|
|
|
7874 }
|
|
|
7875
|
|
|
7876 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCreationFeedbackFlagBits value )
|
|
|
7877 {
|
|
|
7878 switch ( value )
|
|
|
7879 {
|
|
|
7880 case PipelineCreationFeedbackFlagBits::eValid : return "Valid";
|
|
|
7881 case PipelineCreationFeedbackFlagBits::eApplicationPipelineCacheHit: return "ApplicationPipelineCacheHit";
|
|
|
7882 case PipelineCreationFeedbackFlagBits::eBasePipelineAcceleration : return "BasePipelineAcceleration";
|
|
|
7883 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7884 }
|
|
|
7885 }
|
|
|
7886
|
|
|
7887 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( RenderingFlagBits value )
|
|
|
7888 {
|
|
|
7889 switch ( value )
|
|
|
7890 {
|
|
|
7891 case RenderingFlagBits::eContentsSecondaryCommandBuffers : return "ContentsSecondaryCommandBuffers";
|
|
|
7892 case RenderingFlagBits::eSuspending : return "Suspending";
|
|
|
7893 case RenderingFlagBits::eResuming : return "Resuming";
|
|
|
7894 case RenderingFlagBits::eEnableLegacyDitheringEXT : return "EnableLegacyDitheringEXT";
|
|
|
7895 case RenderingFlagBits::eContentsInlineKHR : return "ContentsInlineKHR";
|
|
|
7896 case RenderingFlagBits::ePerLayerFragmentDensityVALVE : return "PerLayerFragmentDensityVALVE";
|
|
|
7897 case RenderingFlagBits::eFragmentRegionEXT : return "FragmentRegionEXT";
|
|
|
7898 case RenderingFlagBits::eCustomResolveEXT : return "CustomResolveEXT";
|
|
|
7899 case RenderingFlagBits::eLocalReadConcurrentAccessControlKHR: return "LocalReadConcurrentAccessControlKHR";
|
|
|
7900 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7901 }
|
|
|
7902 }
|
|
|
7903
|
|
|
7904 //=== VK_VERSION_1_4 ===
|
|
|
7905
|
|
|
7906 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( QueueGlobalPriority value )
|
|
|
7907 {
|
|
|
7908 switch ( value )
|
|
|
7909 {
|
|
|
7910 case QueueGlobalPriority::eLow : return "Low";
|
|
|
7911 case QueueGlobalPriority::eMedium : return "Medium";
|
|
|
7912 case QueueGlobalPriority::eHigh : return "High";
|
|
|
7913 case QueueGlobalPriority::eRealtime: return "Realtime";
|
|
|
7914 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7915 }
|
|
|
7916 }
|
|
|
7917
|
|
|
7918 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MemoryUnmapFlagBits value )
|
|
|
7919 {
|
|
|
7920 switch ( value )
|
|
|
7921 {
|
|
|
7922 case MemoryUnmapFlagBits::eReserveEXT: return "ReserveEXT";
|
|
|
7923 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7924 }
|
|
|
7925 }
|
|
|
7926
|
|
|
7927 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BufferUsageFlagBits2 value )
|
|
|
7928 {
|
|
|
7929 switch ( value )
|
|
|
7930 {
|
|
|
7931 case BufferUsageFlagBits2::eTransferSrc : return "TransferSrc";
|
|
|
7932 case BufferUsageFlagBits2::eTransferDst : return "TransferDst";
|
|
|
7933 case BufferUsageFlagBits2::eUniformTexelBuffer : return "UniformTexelBuffer";
|
|
|
7934 case BufferUsageFlagBits2::eStorageTexelBuffer : return "StorageTexelBuffer";
|
|
|
7935 case BufferUsageFlagBits2::eUniformBuffer : return "UniformBuffer";
|
|
|
7936 case BufferUsageFlagBits2::eStorageBuffer : return "StorageBuffer";
|
|
|
7937 case BufferUsageFlagBits2::eIndexBuffer : return "IndexBuffer";
|
|
|
7938 case BufferUsageFlagBits2::eVertexBuffer : return "VertexBuffer";
|
|
|
7939 case BufferUsageFlagBits2::eIndirectBuffer : return "IndirectBuffer";
|
|
|
7940 case BufferUsageFlagBits2::eShaderDeviceAddress: return "ShaderDeviceAddress";
|
|
|
7941 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
7942 case BufferUsageFlagBits2::eExecutionGraphScratchAMDX: return "ExecutionGraphScratchAMDX";
|
|
|
7943 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
7944 case BufferUsageFlagBits2::eConditionalRenderingEXT : return "ConditionalRenderingEXT";
|
|
|
7945 case BufferUsageFlagBits2::eShaderBindingTableKHR : return "ShaderBindingTableKHR";
|
|
|
7946 case BufferUsageFlagBits2::eTransformFeedbackBufferEXT : return "TransformFeedbackBufferEXT";
|
|
|
7947 case BufferUsageFlagBits2::eTransformFeedbackCounterBufferEXT : return "TransformFeedbackCounterBufferEXT";
|
|
|
7948 case BufferUsageFlagBits2::eVideoDecodeSrcKHR : return "VideoDecodeSrcKHR";
|
|
|
7949 case BufferUsageFlagBits2::eVideoDecodeDstKHR : return "VideoDecodeDstKHR";
|
|
|
7950 case BufferUsageFlagBits2::eVideoEncodeDstKHR : return "VideoEncodeDstKHR";
|
|
|
7951 case BufferUsageFlagBits2::eVideoEncodeSrcKHR : return "VideoEncodeSrcKHR";
|
|
|
7952 case BufferUsageFlagBits2::eAccelerationStructureBuildInputReadOnlyKHR: return "AccelerationStructureBuildInputReadOnlyKHR";
|
|
|
7953 case BufferUsageFlagBits2::eAccelerationStructureStorageKHR : return "AccelerationStructureStorageKHR";
|
|
|
7954 case BufferUsageFlagBits2::eSamplerDescriptorBufferEXT : return "SamplerDescriptorBufferEXT";
|
|
|
7955 case BufferUsageFlagBits2::eResourceDescriptorBufferEXT : return "ResourceDescriptorBufferEXT";
|
|
|
7956 case BufferUsageFlagBits2::ePushDescriptorsDescriptorBufferEXT : return "PushDescriptorsDescriptorBufferEXT";
|
|
|
7957 case BufferUsageFlagBits2::eMicromapBuildInputReadOnlyEXT : return "MicromapBuildInputReadOnlyEXT";
|
|
|
7958 case BufferUsageFlagBits2::eMicromapStorageEXT : return "MicromapStorageEXT";
|
|
|
7959 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
7960 case BufferUsageFlagBits2::eCompressedDataDgf1AMDX: return "CompressedDataDgf1AMDX";
|
|
|
7961 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
7962 case BufferUsageFlagBits2::eDataGraphForeignDescriptorARM: return "DataGraphForeignDescriptorARM";
|
|
|
7963 case BufferUsageFlagBits2::eTileMemoryQCOM : return "TileMemoryQCOM";
|
|
|
7964 case BufferUsageFlagBits2::eMemoryDecompressionEXT : return "MemoryDecompressionEXT";
|
|
|
7965 case BufferUsageFlagBits2::ePreprocessBufferEXT : return "PreprocessBufferEXT";
|
|
|
7966 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7967 }
|
|
|
7968 }
|
|
|
7969
|
|
|
7970 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( HostImageCopyFlagBits value )
|
|
|
7971 {
|
|
|
7972 switch ( value )
|
|
|
7973 {
|
|
|
7974 case HostImageCopyFlagBits::eMemcpy: return "Memcpy";
|
|
|
7975 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
7976 }
|
|
|
7977 }
|
|
|
7978
|
|
|
7979 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCreateFlagBits2 value )
|
|
|
7980 {
|
|
|
7981 switch ( value )
|
|
|
7982 {
|
|
|
7983 case PipelineCreateFlagBits2::eDisableOptimization : return "DisableOptimization";
|
|
|
7984 case PipelineCreateFlagBits2::eAllowDerivatives : return "AllowDerivatives";
|
|
|
7985 case PipelineCreateFlagBits2::eDerivative : return "Derivative";
|
|
|
7986 case PipelineCreateFlagBits2::eViewIndexFromDeviceIndex : return "ViewIndexFromDeviceIndex";
|
|
|
7987 case PipelineCreateFlagBits2::eDispatchBase : return "DispatchBase";
|
|
|
7988 case PipelineCreateFlagBits2::eFailOnPipelineCompileRequired: return "FailOnPipelineCompileRequired";
|
|
|
7989 case PipelineCreateFlagBits2::eEarlyReturnOnFailure : return "EarlyReturnOnFailure";
|
|
|
7990 case PipelineCreateFlagBits2::eNoProtectedAccess : return "NoProtectedAccess";
|
|
|
7991 case PipelineCreateFlagBits2::eProtectedAccessOnly : return "ProtectedAccessOnly";
|
|
|
7992 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
7993 case PipelineCreateFlagBits2::eExecutionGraphAMDX: return "ExecutionGraphAMDX";
|
|
|
7994 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
7995 case PipelineCreateFlagBits2::eRayTracingAllowSpheresAndLinearSweptSpheresNV: return "RayTracingAllowSpheresAndLinearSweptSpheresNV";
|
|
|
7996 case PipelineCreateFlagBits2::eEnableLegacyDitheringEXT : return "EnableLegacyDitheringEXT";
|
|
|
7997 case PipelineCreateFlagBits2::eDeferCompileNV : return "DeferCompileNV";
|
|
|
7998 case PipelineCreateFlagBits2::eCaptureStatisticsKHR : return "CaptureStatisticsKHR";
|
|
|
7999 case PipelineCreateFlagBits2::eCaptureInternalRepresentationsKHR : return "CaptureInternalRepresentationsKHR";
|
|
|
8000 case PipelineCreateFlagBits2::eLinkTimeOptimizationEXT : return "LinkTimeOptimizationEXT";
|
|
|
8001 case PipelineCreateFlagBits2::eRetainLinkTimeOptimizationInfoEXT : return "RetainLinkTimeOptimizationInfoEXT";
|
|
|
8002 case PipelineCreateFlagBits2::eLibraryKHR : return "LibraryKHR";
|
|
|
8003 case PipelineCreateFlagBits2::eRayTracingSkipTrianglesKHR : return "RayTracingSkipTrianglesKHR";
|
|
|
8004 case PipelineCreateFlagBits2::eRayTracingSkipAabbsKHR : return "RayTracingSkipAabbsKHR";
|
|
|
8005 case PipelineCreateFlagBits2::eRayTracingNoNullAnyHitShadersKHR : return "RayTracingNoNullAnyHitShadersKHR";
|
|
|
8006 case PipelineCreateFlagBits2::eRayTracingNoNullClosestHitShadersKHR : return "RayTracingNoNullClosestHitShadersKHR";
|
|
|
8007 case PipelineCreateFlagBits2::eRayTracingNoNullMissShadersKHR : return "RayTracingNoNullMissShadersKHR";
|
|
|
8008 case PipelineCreateFlagBits2::eRayTracingNoNullIntersectionShadersKHR : return "RayTracingNoNullIntersectionShadersKHR";
|
|
|
8009 case PipelineCreateFlagBits2::eRayTracingShaderGroupHandleCaptureReplayKHR : return "RayTracingShaderGroupHandleCaptureReplayKHR";
|
|
|
8010 case PipelineCreateFlagBits2::eIndirectBindableNV : return "IndirectBindableNV";
|
|
|
8011 case PipelineCreateFlagBits2::eRayTracingAllowMotionNV : return "RayTracingAllowMotionNV";
|
|
|
8012 case PipelineCreateFlagBits2::eRenderingFragmentShadingRateAttachmentKHR : return "RenderingFragmentShadingRateAttachmentKHR";
|
|
|
8013 case PipelineCreateFlagBits2::eRenderingFragmentDensityMapAttachmentEXT : return "RenderingFragmentDensityMapAttachmentEXT";
|
|
|
8014 case PipelineCreateFlagBits2::eRayTracingOpacityMicromapEXT : return "RayTracingOpacityMicromapEXT";
|
|
|
8015 case PipelineCreateFlagBits2::eColorAttachmentFeedbackLoopEXT : return "ColorAttachmentFeedbackLoopEXT";
|
|
|
8016 case PipelineCreateFlagBits2::eDepthStencilAttachmentFeedbackLoopEXT : return "DepthStencilAttachmentFeedbackLoopEXT";
|
|
|
8017 case PipelineCreateFlagBits2::eRayTracingDisplacementMicromapNV : return "RayTracingDisplacementMicromapNV";
|
|
|
8018 case PipelineCreateFlagBits2::eDescriptorBufferEXT : return "DescriptorBufferEXT";
|
|
|
8019 case PipelineCreateFlagBits2::eDisallowOpacityMicromapARM : return "DisallowOpacityMicromapARM";
|
|
|
8020 case PipelineCreateFlagBits2::eCaptureDataKHR : return "CaptureDataKHR";
|
|
|
8021 case PipelineCreateFlagBits2::eIndirectBindableEXT : return "IndirectBindableEXT";
|
|
|
8022 case PipelineCreateFlagBits2::ePerLayerFragmentDensityVALVE : return "PerLayerFragmentDensityVALVE";
|
|
|
8023 case PipelineCreateFlagBits2::e64BitIndexingEXT : return "64BitIndexingEXT";
|
|
|
8024 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8025 }
|
|
|
8026 }
|
|
|
8027
|
|
|
8028 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRobustnessBufferBehavior value )
|
|
|
8029 {
|
|
|
8030 switch ( value )
|
|
|
8031 {
|
|
|
8032 case PipelineRobustnessBufferBehavior::eDeviceDefault : return "DeviceDefault";
|
|
|
8033 case PipelineRobustnessBufferBehavior::eDisabled : return "Disabled";
|
|
|
8034 case PipelineRobustnessBufferBehavior::eRobustBufferAccess : return "RobustBufferAccess";
|
|
|
8035 case PipelineRobustnessBufferBehavior::eRobustBufferAccess2: return "RobustBufferAccess2";
|
|
|
8036 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8037 }
|
|
|
8038 }
|
|
|
8039
|
|
|
8040 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRobustnessImageBehavior value )
|
|
|
8041 {
|
|
|
8042 switch ( value )
|
|
|
8043 {
|
|
|
8044 case PipelineRobustnessImageBehavior::eDeviceDefault : return "DeviceDefault";
|
|
|
8045 case PipelineRobustnessImageBehavior::eDisabled : return "Disabled";
|
|
|
8046 case PipelineRobustnessImageBehavior::eRobustImageAccess : return "RobustImageAccess";
|
|
|
8047 case PipelineRobustnessImageBehavior::eRobustImageAccess2: return "RobustImageAccess2";
|
|
|
8048 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8049 }
|
|
|
8050 }
|
|
|
8051
|
|
|
8052 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( LineRasterizationMode value )
|
|
|
8053 {
|
|
|
8054 switch ( value )
|
|
|
8055 {
|
|
|
8056 case LineRasterizationMode::eDefault : return "Default";
|
|
|
8057 case LineRasterizationMode::eRectangular : return "Rectangular";
|
|
|
8058 case LineRasterizationMode::eBresenham : return "Bresenham";
|
|
|
8059 case LineRasterizationMode::eRectangularSmooth: return "RectangularSmooth";
|
|
|
8060 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8061 }
|
|
|
8062 }
|
|
|
8063
|
|
|
8064 //=== VK_KHR_surface ===
|
|
|
8065
|
|
|
8066 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SurfaceTransformFlagBitsKHR value )
|
|
|
8067 {
|
|
|
8068 switch ( value )
|
|
|
8069 {
|
|
|
8070 case SurfaceTransformFlagBitsKHR::eIdentity : return "Identity";
|
|
|
8071 case SurfaceTransformFlagBitsKHR::eRotate90 : return "Rotate90";
|
|
|
8072 case SurfaceTransformFlagBitsKHR::eRotate180 : return "Rotate180";
|
|
|
8073 case SurfaceTransformFlagBitsKHR::eRotate270 : return "Rotate270";
|
|
|
8074 case SurfaceTransformFlagBitsKHR::eHorizontalMirror : return "HorizontalMirror";
|
|
|
8075 case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90 : return "HorizontalMirrorRotate90";
|
|
|
8076 case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180: return "HorizontalMirrorRotate180";
|
|
|
8077 case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270: return "HorizontalMirrorRotate270";
|
|
|
8078 case SurfaceTransformFlagBitsKHR::eInherit : return "Inherit";
|
|
|
8079 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8080 }
|
|
|
8081 }
|
|
|
8082
|
|
|
8083 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PresentModeKHR value )
|
|
|
8084 {
|
|
|
8085 switch ( value )
|
|
|
8086 {
|
|
|
8087 case PresentModeKHR::eImmediate : return "Immediate";
|
|
|
8088 case PresentModeKHR::eMailbox : return "Mailbox";
|
|
|
8089 case PresentModeKHR::eFifo : return "Fifo";
|
|
|
8090 case PresentModeKHR::eFifoRelaxed : return "FifoRelaxed";
|
|
|
8091 case PresentModeKHR::eSharedDemandRefresh : return "SharedDemandRefresh";
|
|
|
8092 case PresentModeKHR::eSharedContinuousRefresh: return "SharedContinuousRefresh";
|
|
|
8093 case PresentModeKHR::eFifoLatestReady : return "FifoLatestReady";
|
|
|
8094 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8095 }
|
|
|
8096 }
|
|
|
8097
|
|
|
8098 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ColorSpaceKHR value )
|
|
|
8099 {
|
|
|
8100 switch ( value )
|
|
|
8101 {
|
|
|
8102 case ColorSpaceKHR::eSrgbNonlinear : return "SrgbNonlinear";
|
|
|
8103 case ColorSpaceKHR::eDisplayP3NonlinearEXT : return "DisplayP3NonlinearEXT";
|
|
|
8104 case ColorSpaceKHR::eExtendedSrgbLinearEXT : return "ExtendedSrgbLinearEXT";
|
|
|
8105 case ColorSpaceKHR::eDisplayP3LinearEXT : return "DisplayP3LinearEXT";
|
|
|
8106 case ColorSpaceKHR::eDciP3NonlinearEXT : return "DciP3NonlinearEXT";
|
|
|
8107 case ColorSpaceKHR::eBt709LinearEXT : return "Bt709LinearEXT";
|
|
|
8108 case ColorSpaceKHR::eBt709NonlinearEXT : return "Bt709NonlinearEXT";
|
|
|
8109 case ColorSpaceKHR::eBt2020LinearEXT : return "Bt2020LinearEXT";
|
|
|
8110 case ColorSpaceKHR::eHdr10St2084EXT : return "Hdr10St2084EXT";
|
|
|
8111 case ColorSpaceKHR::eDolbyvisionEXT : return "DolbyvisionEXT";
|
|
|
8112 case ColorSpaceKHR::eHdr10HlgEXT : return "Hdr10HlgEXT";
|
|
|
8113 case ColorSpaceKHR::eAdobergbLinearEXT : return "AdobergbLinearEXT";
|
|
|
8114 case ColorSpaceKHR::eAdobergbNonlinearEXT : return "AdobergbNonlinearEXT";
|
|
|
8115 case ColorSpaceKHR::ePassThroughEXT : return "PassThroughEXT";
|
|
|
8116 case ColorSpaceKHR::eExtendedSrgbNonlinearEXT: return "ExtendedSrgbNonlinearEXT";
|
|
|
8117 case ColorSpaceKHR::eDisplayNativeAMD : return "DisplayNativeAMD";
|
|
|
8118 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8119 }
|
|
|
8120 }
|
|
|
8121
|
|
|
8122 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CompositeAlphaFlagBitsKHR value )
|
|
|
8123 {
|
|
|
8124 switch ( value )
|
|
|
8125 {
|
|
|
8126 case CompositeAlphaFlagBitsKHR::eOpaque : return "Opaque";
|
|
|
8127 case CompositeAlphaFlagBitsKHR::ePreMultiplied : return "PreMultiplied";
|
|
|
8128 case CompositeAlphaFlagBitsKHR::ePostMultiplied: return "PostMultiplied";
|
|
|
8129 case CompositeAlphaFlagBitsKHR::eInherit : return "Inherit";
|
|
|
8130 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8131 }
|
|
|
8132 }
|
|
|
8133
|
|
|
8134 //=== VK_KHR_swapchain ===
|
|
|
8135
|
|
|
8136 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SwapchainCreateFlagBitsKHR value )
|
|
|
8137 {
|
|
|
8138 switch ( value )
|
|
|
8139 {
|
|
|
8140 case SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions: return "SplitInstanceBindRegions";
|
|
|
8141 case SwapchainCreateFlagBitsKHR::eProtected : return "Protected";
|
|
|
8142 case SwapchainCreateFlagBitsKHR::eMutableFormat : return "MutableFormat";
|
|
|
8143 case SwapchainCreateFlagBitsKHR::ePresentId2 : return "PresentId2";
|
|
|
8144 case SwapchainCreateFlagBitsKHR::ePresentWait2 : return "PresentWait2";
|
|
|
8145 case SwapchainCreateFlagBitsKHR::eDeferredMemoryAllocation: return "DeferredMemoryAllocation";
|
|
|
8146 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8147 }
|
|
|
8148 }
|
|
|
8149
|
|
|
8150 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceGroupPresentModeFlagBitsKHR value )
|
|
|
8151 {
|
|
|
8152 switch ( value )
|
|
|
8153 {
|
|
|
8154 case DeviceGroupPresentModeFlagBitsKHR::eLocal : return "Local";
|
|
|
8155 case DeviceGroupPresentModeFlagBitsKHR::eRemote : return "Remote";
|
|
|
8156 case DeviceGroupPresentModeFlagBitsKHR::eSum : return "Sum";
|
|
|
8157 case DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice: return "LocalMultiDevice";
|
|
|
8158 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8159 }
|
|
|
8160 }
|
|
|
8161
|
|
|
8162 //=== VK_KHR_display ===
|
|
|
8163
|
|
|
8164 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DisplayPlaneAlphaFlagBitsKHR value )
|
|
|
8165 {
|
|
|
8166 switch ( value )
|
|
|
8167 {
|
|
|
8168 case DisplayPlaneAlphaFlagBitsKHR::eOpaque : return "Opaque";
|
|
|
8169 case DisplayPlaneAlphaFlagBitsKHR::eGlobal : return "Global";
|
|
|
8170 case DisplayPlaneAlphaFlagBitsKHR::ePerPixel : return "PerPixel";
|
|
|
8171 case DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied: return "PerPixelPremultiplied";
|
|
|
8172 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8173 }
|
|
|
8174 }
|
|
|
8175
|
|
|
8176 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DisplayModeCreateFlagBitsKHR )
|
|
|
8177 {
|
|
|
8178 return "(void)";
|
|
|
8179 }
|
|
|
8180
|
|
|
8181 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DisplaySurfaceCreateFlagBitsKHR )
|
|
|
8182 {
|
|
|
8183 return "(void)";
|
|
|
8184 }
|
|
|
8185
|
|
|
8186 #if defined( VK_USE_PLATFORM_XLIB_KHR )
|
|
|
8187 //=== VK_KHR_xlib_surface ===
|
|
|
8188
|
|
|
8189 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( XlibSurfaceCreateFlagBitsKHR )
|
|
|
8190 {
|
|
|
8191 return "(void)";
|
|
|
8192 }
|
|
|
8193 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
|
|
|
8194
|
|
|
8195 #if defined( VK_USE_PLATFORM_XCB_KHR )
|
|
|
8196 //=== VK_KHR_xcb_surface ===
|
|
|
8197
|
|
|
8198 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( XcbSurfaceCreateFlagBitsKHR )
|
|
|
8199 {
|
|
|
8200 return "(void)";
|
|
|
8201 }
|
|
|
8202 #endif /*VK_USE_PLATFORM_XCB_KHR*/
|
|
|
8203
|
|
|
8204 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
|
|
|
8205 //=== VK_KHR_wayland_surface ===
|
|
|
8206
|
|
|
8207 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( WaylandSurfaceCreateFlagBitsKHR )
|
|
|
8208 {
|
|
|
8209 return "(void)";
|
|
|
8210 }
|
|
|
8211 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
|
|
|
8212
|
|
|
8213 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
|
8214 //=== VK_KHR_android_surface ===
|
|
|
8215
|
|
|
8216 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AndroidSurfaceCreateFlagBitsKHR )
|
|
|
8217 {
|
|
|
8218 return "(void)";
|
|
|
8219 }
|
|
|
8220 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
8221
|
|
|
8222 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
8223 //=== VK_KHR_win32_surface ===
|
|
|
8224
|
|
|
8225 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( Win32SurfaceCreateFlagBitsKHR )
|
|
|
8226 {
|
|
|
8227 return "(void)";
|
|
|
8228 }
|
|
|
8229 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
8230
|
|
|
8231 //=== VK_EXT_debug_report ===
|
|
|
8232
|
|
|
8233 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DebugReportFlagBitsEXT value )
|
|
|
8234 {
|
|
|
8235 switch ( value )
|
|
|
8236 {
|
|
|
8237 case DebugReportFlagBitsEXT::eInformation : return "Information";
|
|
|
8238 case DebugReportFlagBitsEXT::eWarning : return "Warning";
|
|
|
8239 case DebugReportFlagBitsEXT::ePerformanceWarning: return "PerformanceWarning";
|
|
|
8240 case DebugReportFlagBitsEXT::eError : return "Error";
|
|
|
8241 case DebugReportFlagBitsEXT::eDebug : return "Debug";
|
|
|
8242 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8243 }
|
|
|
8244 }
|
|
|
8245
|
|
|
8246 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DebugReportObjectTypeEXT value )
|
|
|
8247 {
|
|
|
8248 switch ( value )
|
|
|
8249 {
|
|
|
8250 case DebugReportObjectTypeEXT::eUnknown : return "Unknown";
|
|
|
8251 case DebugReportObjectTypeEXT::eInstance : return "Instance";
|
|
|
8252 case DebugReportObjectTypeEXT::ePhysicalDevice : return "PhysicalDevice";
|
|
|
8253 case DebugReportObjectTypeEXT::eDevice : return "Device";
|
|
|
8254 case DebugReportObjectTypeEXT::eQueue : return "Queue";
|
|
|
8255 case DebugReportObjectTypeEXT::eSemaphore : return "Semaphore";
|
|
|
8256 case DebugReportObjectTypeEXT::eCommandBuffer : return "CommandBuffer";
|
|
|
8257 case DebugReportObjectTypeEXT::eFence : return "Fence";
|
|
|
8258 case DebugReportObjectTypeEXT::eDeviceMemory : return "DeviceMemory";
|
|
|
8259 case DebugReportObjectTypeEXT::eBuffer : return "Buffer";
|
|
|
8260 case DebugReportObjectTypeEXT::eImage : return "Image";
|
|
|
8261 case DebugReportObjectTypeEXT::eEvent : return "Event";
|
|
|
8262 case DebugReportObjectTypeEXT::eQueryPool : return "QueryPool";
|
|
|
8263 case DebugReportObjectTypeEXT::eBufferView : return "BufferView";
|
|
|
8264 case DebugReportObjectTypeEXT::eImageView : return "ImageView";
|
|
|
8265 case DebugReportObjectTypeEXT::eShaderModule : return "ShaderModule";
|
|
|
8266 case DebugReportObjectTypeEXT::ePipelineCache : return "PipelineCache";
|
|
|
8267 case DebugReportObjectTypeEXT::ePipelineLayout : return "PipelineLayout";
|
|
|
8268 case DebugReportObjectTypeEXT::eRenderPass : return "RenderPass";
|
|
|
8269 case DebugReportObjectTypeEXT::ePipeline : return "Pipeline";
|
|
|
8270 case DebugReportObjectTypeEXT::eDescriptorSetLayout : return "DescriptorSetLayout";
|
|
|
8271 case DebugReportObjectTypeEXT::eSampler : return "Sampler";
|
|
|
8272 case DebugReportObjectTypeEXT::eDescriptorPool : return "DescriptorPool";
|
|
|
8273 case DebugReportObjectTypeEXT::eDescriptorSet : return "DescriptorSet";
|
|
|
8274 case DebugReportObjectTypeEXT::eFramebuffer : return "Framebuffer";
|
|
|
8275 case DebugReportObjectTypeEXT::eCommandPool : return "CommandPool";
|
|
|
8276 case DebugReportObjectTypeEXT::eSurfaceKHR : return "SurfaceKHR";
|
|
|
8277 case DebugReportObjectTypeEXT::eSwapchainKHR : return "SwapchainKHR";
|
|
|
8278 case DebugReportObjectTypeEXT::eDebugReportCallbackEXT : return "DebugReportCallbackEXT";
|
|
|
8279 case DebugReportObjectTypeEXT::eDisplayKHR : return "DisplayKHR";
|
|
|
8280 case DebugReportObjectTypeEXT::eDisplayModeKHR : return "DisplayModeKHR";
|
|
|
8281 case DebugReportObjectTypeEXT::eValidationCacheEXT : return "ValidationCacheEXT";
|
|
|
8282 case DebugReportObjectTypeEXT::eSamplerYcbcrConversion : return "SamplerYcbcrConversion";
|
|
|
8283 case DebugReportObjectTypeEXT::eDescriptorUpdateTemplate: return "DescriptorUpdateTemplate";
|
|
|
8284 case DebugReportObjectTypeEXT::eCuModuleNVX : return "CuModuleNVX";
|
|
|
8285 case DebugReportObjectTypeEXT::eCuFunctionNVX : return "CuFunctionNVX";
|
|
|
8286 case DebugReportObjectTypeEXT::eAccelerationStructureKHR: return "AccelerationStructureKHR";
|
|
|
8287 case DebugReportObjectTypeEXT::eAccelerationStructureNV : return "AccelerationStructureNV";
|
|
|
8288 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
8289 case DebugReportObjectTypeEXT::eCudaModuleNV : return "CudaModuleNV";
|
|
|
8290 case DebugReportObjectTypeEXT::eCudaFunctionNV: return "CudaFunctionNV";
|
|
|
8291 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
8292 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
8293 case DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA: return "BufferCollectionFUCHSIA";
|
|
|
8294 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
8295 default: return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8296 }
|
|
|
8297 }
|
|
|
8298
|
|
|
8299 //=== VK_AMD_rasterization_order ===
|
|
|
8300
|
|
|
8301 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( RasterizationOrderAMD value )
|
|
|
8302 {
|
|
|
8303 switch ( value )
|
|
|
8304 {
|
|
|
8305 case RasterizationOrderAMD::eStrict : return "Strict";
|
|
|
8306 case RasterizationOrderAMD::eRelaxed: return "Relaxed";
|
|
|
8307 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8308 }
|
|
|
8309 }
|
|
|
8310
|
|
|
8311 //=== VK_KHR_video_queue ===
|
|
|
8312
|
|
|
8313 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoCodecOperationFlagBitsKHR value )
|
|
|
8314 {
|
|
|
8315 switch ( value )
|
|
|
8316 {
|
|
|
8317 case VideoCodecOperationFlagBitsKHR::eNone : return "None";
|
|
|
8318 case VideoCodecOperationFlagBitsKHR::eEncodeH264: return "EncodeH264";
|
|
|
8319 case VideoCodecOperationFlagBitsKHR::eEncodeH265: return "EncodeH265";
|
|
|
8320 case VideoCodecOperationFlagBitsKHR::eDecodeH264: return "DecodeH264";
|
|
|
8321 case VideoCodecOperationFlagBitsKHR::eDecodeH265: return "DecodeH265";
|
|
|
8322 case VideoCodecOperationFlagBitsKHR::eDecodeAv1 : return "DecodeAv1";
|
|
|
8323 case VideoCodecOperationFlagBitsKHR::eEncodeAv1 : return "EncodeAv1";
|
|
|
8324 case VideoCodecOperationFlagBitsKHR::eDecodeVp9 : return "DecodeVp9";
|
|
|
8325 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8326 }
|
|
|
8327 }
|
|
|
8328
|
|
|
8329 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoChromaSubsamplingFlagBitsKHR value )
|
|
|
8330 {
|
|
|
8331 switch ( value )
|
|
|
8332 {
|
|
|
8333 case VideoChromaSubsamplingFlagBitsKHR::eInvalid : return "Invalid";
|
|
|
8334 case VideoChromaSubsamplingFlagBitsKHR::eMonochrome: return "Monochrome";
|
|
|
8335 case VideoChromaSubsamplingFlagBitsKHR::e420 : return "420";
|
|
|
8336 case VideoChromaSubsamplingFlagBitsKHR::e422 : return "422";
|
|
|
8337 case VideoChromaSubsamplingFlagBitsKHR::e444 : return "444";
|
|
|
8338 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8339 }
|
|
|
8340 }
|
|
|
8341
|
|
|
8342 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoComponentBitDepthFlagBitsKHR value )
|
|
|
8343 {
|
|
|
8344 switch ( value )
|
|
|
8345 {
|
|
|
8346 case VideoComponentBitDepthFlagBitsKHR::eInvalid: return "Invalid";
|
|
|
8347 case VideoComponentBitDepthFlagBitsKHR::e8 : return "8";
|
|
|
8348 case VideoComponentBitDepthFlagBitsKHR::e10 : return "10";
|
|
|
8349 case VideoComponentBitDepthFlagBitsKHR::e12 : return "12";
|
|
|
8350 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8351 }
|
|
|
8352 }
|
|
|
8353
|
|
|
8354 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoCapabilityFlagBitsKHR value )
|
|
|
8355 {
|
|
|
8356 switch ( value )
|
|
|
8357 {
|
|
|
8358 case VideoCapabilityFlagBitsKHR::eProtectedContent : return "ProtectedContent";
|
|
|
8359 case VideoCapabilityFlagBitsKHR::eSeparateReferenceImages: return "SeparateReferenceImages";
|
|
|
8360 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8361 }
|
|
|
8362 }
|
|
|
8363
|
|
|
8364 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoSessionCreateFlagBitsKHR value )
|
|
|
8365 {
|
|
|
8366 switch ( value )
|
|
|
8367 {
|
|
|
8368 case VideoSessionCreateFlagBitsKHR::eProtectedContent : return "ProtectedContent";
|
|
|
8369 case VideoSessionCreateFlagBitsKHR::eAllowEncodeParameterOptimizations: return "AllowEncodeParameterOptimizations";
|
|
|
8370 case VideoSessionCreateFlagBitsKHR::eInlineQueries : return "InlineQueries";
|
|
|
8371 case VideoSessionCreateFlagBitsKHR::eAllowEncodeQuantizationDeltaMap : return "AllowEncodeQuantizationDeltaMap";
|
|
|
8372 case VideoSessionCreateFlagBitsKHR::eAllowEncodeEmphasisMap : return "AllowEncodeEmphasisMap";
|
|
|
8373 case VideoSessionCreateFlagBitsKHR::eInlineSessionParameters : return "InlineSessionParameters";
|
|
|
8374 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8375 }
|
|
|
8376 }
|
|
|
8377
|
|
|
8378 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoCodingControlFlagBitsKHR value )
|
|
|
8379 {
|
|
|
8380 switch ( value )
|
|
|
8381 {
|
|
|
8382 case VideoCodingControlFlagBitsKHR::eReset : return "Reset";
|
|
|
8383 case VideoCodingControlFlagBitsKHR::eEncodeRateControl : return "EncodeRateControl";
|
|
|
8384 case VideoCodingControlFlagBitsKHR::eEncodeQualityLevel: return "EncodeQualityLevel";
|
|
|
8385 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8386 }
|
|
|
8387 }
|
|
|
8388
|
|
|
8389 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( QueryResultStatusKHR value )
|
|
|
8390 {
|
|
|
8391 switch ( value )
|
|
|
8392 {
|
|
|
8393 case QueryResultStatusKHR::eError : return "Error";
|
|
|
8394 case QueryResultStatusKHR::eNotReady : return "NotReady";
|
|
|
8395 case QueryResultStatusKHR::eComplete : return "Complete";
|
|
|
8396 case QueryResultStatusKHR::eInsufficientBitstreamBufferRange: return "InsufficientBitstreamBufferRange";
|
|
|
8397 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8398 }
|
|
|
8399 }
|
|
|
8400
|
|
|
8401 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoSessionParametersCreateFlagBitsKHR value )
|
|
|
8402 {
|
|
|
8403 switch ( value )
|
|
|
8404 {
|
|
|
8405 case VideoSessionParametersCreateFlagBitsKHR::eQuantizationMapCompatible: return "QuantizationMapCompatible";
|
|
|
8406 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8407 }
|
|
|
8408 }
|
|
|
8409
|
|
|
8410 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoBeginCodingFlagBitsKHR )
|
|
|
8411 {
|
|
|
8412 return "(void)";
|
|
|
8413 }
|
|
|
8414
|
|
|
8415 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEndCodingFlagBitsKHR )
|
|
|
8416 {
|
|
|
8417 return "(void)";
|
|
|
8418 }
|
|
|
8419
|
|
|
8420 //=== VK_KHR_video_decode_queue ===
|
|
|
8421
|
|
|
8422 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoDecodeCapabilityFlagBitsKHR value )
|
|
|
8423 {
|
|
|
8424 switch ( value )
|
|
|
8425 {
|
|
|
8426 case VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputCoincide: return "DpbAndOutputCoincide";
|
|
|
8427 case VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputDistinct: return "DpbAndOutputDistinct";
|
|
|
8428 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8429 }
|
|
|
8430 }
|
|
|
8431
|
|
|
8432 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoDecodeUsageFlagBitsKHR value )
|
|
|
8433 {
|
|
|
8434 switch ( value )
|
|
|
8435 {
|
|
|
8436 case VideoDecodeUsageFlagBitsKHR::eDefault : return "Default";
|
|
|
8437 case VideoDecodeUsageFlagBitsKHR::eTranscoding: return "Transcoding";
|
|
|
8438 case VideoDecodeUsageFlagBitsKHR::eOffline : return "Offline";
|
|
|
8439 case VideoDecodeUsageFlagBitsKHR::eStreaming : return "Streaming";
|
|
|
8440 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8441 }
|
|
|
8442 }
|
|
|
8443
|
|
|
8444 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoDecodeFlagBitsKHR )
|
|
|
8445 {
|
|
|
8446 return "(void)";
|
|
|
8447 }
|
|
|
8448
|
|
|
8449 //=== VK_EXT_transform_feedback ===
|
|
|
8450
|
|
|
8451 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRasterizationStateStreamCreateFlagBitsEXT )
|
|
|
8452 {
|
|
|
8453 return "(void)";
|
|
|
8454 }
|
|
|
8455
|
|
|
8456 //=== VK_KHR_video_encode_h264 ===
|
|
|
8457
|
|
|
8458 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeH264CapabilityFlagBitsKHR value )
|
|
|
8459 {
|
|
|
8460 switch ( value )
|
|
|
8461 {
|
|
|
8462 case VideoEncodeH264CapabilityFlagBitsKHR::eHrdCompliance : return "HrdCompliance";
|
|
|
8463 case VideoEncodeH264CapabilityFlagBitsKHR::ePredictionWeightTableGenerated: return "PredictionWeightTableGenerated";
|
|
|
8464 case VideoEncodeH264CapabilityFlagBitsKHR::eRowUnalignedSlice : return "RowUnalignedSlice";
|
|
|
8465 case VideoEncodeH264CapabilityFlagBitsKHR::eDifferentSliceType : return "DifferentSliceType";
|
|
|
8466 case VideoEncodeH264CapabilityFlagBitsKHR::eBFrameInL0List : return "BFrameInL0List";
|
|
|
8467 case VideoEncodeH264CapabilityFlagBitsKHR::eBFrameInL1List : return "BFrameInL1List";
|
|
|
8468 case VideoEncodeH264CapabilityFlagBitsKHR::ePerPictureTypeMinMaxQp : return "PerPictureTypeMinMaxQp";
|
|
|
8469 case VideoEncodeH264CapabilityFlagBitsKHR::ePerSliceConstantQp : return "PerSliceConstantQp";
|
|
|
8470 case VideoEncodeH264CapabilityFlagBitsKHR::eGeneratePrefixNalu : return "GeneratePrefixNalu";
|
|
|
8471 case VideoEncodeH264CapabilityFlagBitsKHR::eBPictureIntraRefresh : return "BPictureIntraRefresh";
|
|
|
8472 case VideoEncodeH264CapabilityFlagBitsKHR::eMbQpDiffWraparound : return "MbQpDiffWraparound";
|
|
|
8473 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8474 }
|
|
|
8475 }
|
|
|
8476
|
|
|
8477 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeH264StdFlagBitsKHR value )
|
|
|
8478 {
|
|
|
8479 switch ( value )
|
|
|
8480 {
|
|
|
8481 case VideoEncodeH264StdFlagBitsKHR::eSeparateColorPlaneFlagSet : return "SeparateColorPlaneFlagSet";
|
|
|
8482 case VideoEncodeH264StdFlagBitsKHR::eQpprimeYZeroTransformBypassFlagSet: return "QpprimeYZeroTransformBypassFlagSet";
|
|
|
8483 case VideoEncodeH264StdFlagBitsKHR::eScalingMatrixPresentFlagSet : return "ScalingMatrixPresentFlagSet";
|
|
|
8484 case VideoEncodeH264StdFlagBitsKHR::eChromaQpIndexOffset : return "ChromaQpIndexOffset";
|
|
|
8485 case VideoEncodeH264StdFlagBitsKHR::eSecondChromaQpIndexOffset : return "SecondChromaQpIndexOffset";
|
|
|
8486 case VideoEncodeH264StdFlagBitsKHR::ePicInitQpMinus26 : return "PicInitQpMinus26";
|
|
|
8487 case VideoEncodeH264StdFlagBitsKHR::eWeightedPredFlagSet : return "WeightedPredFlagSet";
|
|
|
8488 case VideoEncodeH264StdFlagBitsKHR::eWeightedBipredIdcExplicit : return "WeightedBipredIdcExplicit";
|
|
|
8489 case VideoEncodeH264StdFlagBitsKHR::eWeightedBipredIdcImplicit : return "WeightedBipredIdcImplicit";
|
|
|
8490 case VideoEncodeH264StdFlagBitsKHR::eTransform8X8ModeFlagSet : return "Transform8X8ModeFlagSet";
|
|
|
8491 case VideoEncodeH264StdFlagBitsKHR::eDirectSpatialMvPredFlagUnset : return "DirectSpatialMvPredFlagUnset";
|
|
|
8492 case VideoEncodeH264StdFlagBitsKHR::eEntropyCodingModeFlagUnset : return "EntropyCodingModeFlagUnset";
|
|
|
8493 case VideoEncodeH264StdFlagBitsKHR::eEntropyCodingModeFlagSet : return "EntropyCodingModeFlagSet";
|
|
|
8494 case VideoEncodeH264StdFlagBitsKHR::eDirect8X8InferenceFlagUnset : return "Direct8X8InferenceFlagUnset";
|
|
|
8495 case VideoEncodeH264StdFlagBitsKHR::eConstrainedIntraPredFlagSet : return "ConstrainedIntraPredFlagSet";
|
|
|
8496 case VideoEncodeH264StdFlagBitsKHR::eDeblockingFilterDisabled : return "DeblockingFilterDisabled";
|
|
|
8497 case VideoEncodeH264StdFlagBitsKHR::eDeblockingFilterEnabled : return "DeblockingFilterEnabled";
|
|
|
8498 case VideoEncodeH264StdFlagBitsKHR::eDeblockingFilterPartial : return "DeblockingFilterPartial";
|
|
|
8499 case VideoEncodeH264StdFlagBitsKHR::eSliceQpDelta : return "SliceQpDelta";
|
|
|
8500 case VideoEncodeH264StdFlagBitsKHR::eDifferentSliceQpDelta : return "DifferentSliceQpDelta";
|
|
|
8501 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8502 }
|
|
|
8503 }
|
|
|
8504
|
|
|
8505 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeH264RateControlFlagBitsKHR value )
|
|
|
8506 {
|
|
|
8507 switch ( value )
|
|
|
8508 {
|
|
|
8509 case VideoEncodeH264RateControlFlagBitsKHR::eAttemptHrdCompliance : return "AttemptHrdCompliance";
|
|
|
8510 case VideoEncodeH264RateControlFlagBitsKHR::eRegularGop : return "RegularGop";
|
|
|
8511 case VideoEncodeH264RateControlFlagBitsKHR::eReferencePatternFlat : return "ReferencePatternFlat";
|
|
|
8512 case VideoEncodeH264RateControlFlagBitsKHR::eReferencePatternDyadic : return "ReferencePatternDyadic";
|
|
|
8513 case VideoEncodeH264RateControlFlagBitsKHR::eTemporalLayerPatternDyadic: return "TemporalLayerPatternDyadic";
|
|
|
8514 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8515 }
|
|
|
8516 }
|
|
|
8517
|
|
|
8518 //=== VK_KHR_video_encode_h265 ===
|
|
|
8519
|
|
|
8520 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeH265CapabilityFlagBitsKHR value )
|
|
|
8521 {
|
|
|
8522 switch ( value )
|
|
|
8523 {
|
|
|
8524 case VideoEncodeH265CapabilityFlagBitsKHR::eHrdCompliance : return "HrdCompliance";
|
|
|
8525 case VideoEncodeH265CapabilityFlagBitsKHR::ePredictionWeightTableGenerated: return "PredictionWeightTableGenerated";
|
|
|
8526 case VideoEncodeH265CapabilityFlagBitsKHR::eRowUnalignedSliceSegment : return "RowUnalignedSliceSegment";
|
|
|
8527 case VideoEncodeH265CapabilityFlagBitsKHR::eDifferentSliceSegmentType : return "DifferentSliceSegmentType";
|
|
|
8528 case VideoEncodeH265CapabilityFlagBitsKHR::eBFrameInL0List : return "BFrameInL0List";
|
|
|
8529 case VideoEncodeH265CapabilityFlagBitsKHR::eBFrameInL1List : return "BFrameInL1List";
|
|
|
8530 case VideoEncodeH265CapabilityFlagBitsKHR::ePerPictureTypeMinMaxQp : return "PerPictureTypeMinMaxQp";
|
|
|
8531 case VideoEncodeH265CapabilityFlagBitsKHR::ePerSliceSegmentConstantQp : return "PerSliceSegmentConstantQp";
|
|
|
8532 case VideoEncodeH265CapabilityFlagBitsKHR::eMultipleTilesPerSliceSegment : return "MultipleTilesPerSliceSegment";
|
|
|
8533 case VideoEncodeH265CapabilityFlagBitsKHR::eMultipleSliceSegmentsPerTile : return "MultipleSliceSegmentsPerTile";
|
|
|
8534 case VideoEncodeH265CapabilityFlagBitsKHR::eBPictureIntraRefresh : return "BPictureIntraRefresh";
|
|
|
8535 case VideoEncodeH265CapabilityFlagBitsKHR::eCuQpDiffWraparound : return "CuQpDiffWraparound";
|
|
|
8536 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8537 }
|
|
|
8538 }
|
|
|
8539
|
|
|
8540 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeH265StdFlagBitsKHR value )
|
|
|
8541 {
|
|
|
8542 switch ( value )
|
|
|
8543 {
|
|
|
8544 case VideoEncodeH265StdFlagBitsKHR::eSeparateColorPlaneFlagSet : return "SeparateColorPlaneFlagSet";
|
|
|
8545 case VideoEncodeH265StdFlagBitsKHR::eSampleAdaptiveOffsetEnabledFlagSet : return "SampleAdaptiveOffsetEnabledFlagSet";
|
|
|
8546 case VideoEncodeH265StdFlagBitsKHR::eScalingListDataPresentFlagSet : return "ScalingListDataPresentFlagSet";
|
|
|
8547 case VideoEncodeH265StdFlagBitsKHR::ePcmEnabledFlagSet : return "PcmEnabledFlagSet";
|
|
|
8548 case VideoEncodeH265StdFlagBitsKHR::eSpsTemporalMvpEnabledFlagSet : return "SpsTemporalMvpEnabledFlagSet";
|
|
|
8549 case VideoEncodeH265StdFlagBitsKHR::eInitQpMinus26 : return "InitQpMinus26";
|
|
|
8550 case VideoEncodeH265StdFlagBitsKHR::eWeightedPredFlagSet : return "WeightedPredFlagSet";
|
|
|
8551 case VideoEncodeH265StdFlagBitsKHR::eWeightedBipredFlagSet : return "WeightedBipredFlagSet";
|
|
|
8552 case VideoEncodeH265StdFlagBitsKHR::eLog2ParallelMergeLevelMinus2 : return "Log2ParallelMergeLevelMinus2";
|
|
|
8553 case VideoEncodeH265StdFlagBitsKHR::eSignDataHidingEnabledFlagSet : return "SignDataHidingEnabledFlagSet";
|
|
|
8554 case VideoEncodeH265StdFlagBitsKHR::eTransformSkipEnabledFlagSet : return "TransformSkipEnabledFlagSet";
|
|
|
8555 case VideoEncodeH265StdFlagBitsKHR::eTransformSkipEnabledFlagUnset : return "TransformSkipEnabledFlagUnset";
|
|
|
8556 case VideoEncodeH265StdFlagBitsKHR::ePpsSliceChromaQpOffsetsPresentFlagSet : return "PpsSliceChromaQpOffsetsPresentFlagSet";
|
|
|
8557 case VideoEncodeH265StdFlagBitsKHR::eTransquantBypassEnabledFlagSet : return "TransquantBypassEnabledFlagSet";
|
|
|
8558 case VideoEncodeH265StdFlagBitsKHR::eConstrainedIntraPredFlagSet : return "ConstrainedIntraPredFlagSet";
|
|
|
8559 case VideoEncodeH265StdFlagBitsKHR::eEntropyCodingSyncEnabledFlagSet : return "EntropyCodingSyncEnabledFlagSet";
|
|
|
8560 case VideoEncodeH265StdFlagBitsKHR::eDeblockingFilterOverrideEnabledFlagSet: return "DeblockingFilterOverrideEnabledFlagSet";
|
|
|
8561 case VideoEncodeH265StdFlagBitsKHR::eDependentSliceSegmentsEnabledFlagSet : return "DependentSliceSegmentsEnabledFlagSet";
|
|
|
8562 case VideoEncodeH265StdFlagBitsKHR::eDependentSliceSegmentFlagSet : return "DependentSliceSegmentFlagSet";
|
|
|
8563 case VideoEncodeH265StdFlagBitsKHR::eSliceQpDelta : return "SliceQpDelta";
|
|
|
8564 case VideoEncodeH265StdFlagBitsKHR::eDifferentSliceQpDelta : return "DifferentSliceQpDelta";
|
|
|
8565 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8566 }
|
|
|
8567 }
|
|
|
8568
|
|
|
8569 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeH265CtbSizeFlagBitsKHR value )
|
|
|
8570 {
|
|
|
8571 switch ( value )
|
|
|
8572 {
|
|
|
8573 case VideoEncodeH265CtbSizeFlagBitsKHR::e16: return "16";
|
|
|
8574 case VideoEncodeH265CtbSizeFlagBitsKHR::e32: return "32";
|
|
|
8575 case VideoEncodeH265CtbSizeFlagBitsKHR::e64: return "64";
|
|
|
8576 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8577 }
|
|
|
8578 }
|
|
|
8579
|
|
|
8580 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeH265TransformBlockSizeFlagBitsKHR value )
|
|
|
8581 {
|
|
|
8582 switch ( value )
|
|
|
8583 {
|
|
|
8584 case VideoEncodeH265TransformBlockSizeFlagBitsKHR::e4 : return "4";
|
|
|
8585 case VideoEncodeH265TransformBlockSizeFlagBitsKHR::e8 : return "8";
|
|
|
8586 case VideoEncodeH265TransformBlockSizeFlagBitsKHR::e16: return "16";
|
|
|
8587 case VideoEncodeH265TransformBlockSizeFlagBitsKHR::e32: return "32";
|
|
|
8588 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8589 }
|
|
|
8590 }
|
|
|
8591
|
|
|
8592 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeH265RateControlFlagBitsKHR value )
|
|
|
8593 {
|
|
|
8594 switch ( value )
|
|
|
8595 {
|
|
|
8596 case VideoEncodeH265RateControlFlagBitsKHR::eAttemptHrdCompliance : return "AttemptHrdCompliance";
|
|
|
8597 case VideoEncodeH265RateControlFlagBitsKHR::eRegularGop : return "RegularGop";
|
|
|
8598 case VideoEncodeH265RateControlFlagBitsKHR::eReferencePatternFlat : return "ReferencePatternFlat";
|
|
|
8599 case VideoEncodeH265RateControlFlagBitsKHR::eReferencePatternDyadic : return "ReferencePatternDyadic";
|
|
|
8600 case VideoEncodeH265RateControlFlagBitsKHR::eTemporalSubLayerPatternDyadic: return "TemporalSubLayerPatternDyadic";
|
|
|
8601 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8602 }
|
|
|
8603 }
|
|
|
8604
|
|
|
8605 //=== VK_KHR_video_decode_h264 ===
|
|
|
8606
|
|
|
8607 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoDecodeH264PictureLayoutFlagBitsKHR value )
|
|
|
8608 {
|
|
|
8609 switch ( value )
|
|
|
8610 {
|
|
|
8611 case VideoDecodeH264PictureLayoutFlagBitsKHR::eProgressive : return "Progressive";
|
|
|
8612 case VideoDecodeH264PictureLayoutFlagBitsKHR::eInterlacedInterleavedLines: return "InterlacedInterleavedLines";
|
|
|
8613 case VideoDecodeH264PictureLayoutFlagBitsKHR::eInterlacedSeparatePlanes : return "InterlacedSeparatePlanes";
|
|
|
8614 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8615 }
|
|
|
8616 }
|
|
|
8617
|
|
|
8618 //=== VK_AMD_shader_info ===
|
|
|
8619
|
|
|
8620 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderInfoTypeAMD value )
|
|
|
8621 {
|
|
|
8622 switch ( value )
|
|
|
8623 {
|
|
|
8624 case ShaderInfoTypeAMD::eStatistics : return "Statistics";
|
|
|
8625 case ShaderInfoTypeAMD::eBinary : return "Binary";
|
|
|
8626 case ShaderInfoTypeAMD::eDisassembly: return "Disassembly";
|
|
|
8627 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8628 }
|
|
|
8629 }
|
|
|
8630
|
|
|
8631 #if defined( VK_USE_PLATFORM_GGP )
|
|
|
8632 //=== VK_GGP_stream_descriptor_surface ===
|
|
|
8633
|
|
|
8634 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( StreamDescriptorSurfaceCreateFlagBitsGGP )
|
|
|
8635 {
|
|
|
8636 return "(void)";
|
|
|
8637 }
|
|
|
8638 #endif /*VK_USE_PLATFORM_GGP*/
|
|
|
8639
|
|
|
8640 //=== VK_NV_external_memory_capabilities ===
|
|
|
8641
|
|
|
8642 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ExternalMemoryHandleTypeFlagBitsNV value )
|
|
|
8643 {
|
|
|
8644 switch ( value )
|
|
|
8645 {
|
|
|
8646 case ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32 : return "OpaqueWin32";
|
|
|
8647 case ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt: return "OpaqueWin32Kmt";
|
|
|
8648 case ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image : return "D3D11Image";
|
|
|
8649 case ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt : return "D3D11ImageKmt";
|
|
|
8650 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8651 }
|
|
|
8652 }
|
|
|
8653
|
|
|
8654 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ExternalMemoryFeatureFlagBitsNV value )
|
|
|
8655 {
|
|
|
8656 switch ( value )
|
|
|
8657 {
|
|
|
8658 case ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly: return "DedicatedOnly";
|
|
|
8659 case ExternalMemoryFeatureFlagBitsNV::eExportable : return "Exportable";
|
|
|
8660 case ExternalMemoryFeatureFlagBitsNV::eImportable : return "Importable";
|
|
|
8661 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8662 }
|
|
|
8663 }
|
|
|
8664
|
|
|
8665 //=== VK_EXT_validation_flags ===
|
|
|
8666
|
|
|
8667 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ValidationCheckEXT value )
|
|
|
8668 {
|
|
|
8669 switch ( value )
|
|
|
8670 {
|
|
|
8671 case ValidationCheckEXT::eAll : return "All";
|
|
|
8672 case ValidationCheckEXT::eShaders: return "Shaders";
|
|
|
8673 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8674 }
|
|
|
8675 }
|
|
|
8676
|
|
|
8677 #if defined( VK_USE_PLATFORM_VI_NN )
|
|
|
8678 //=== VK_NN_vi_surface ===
|
|
|
8679
|
|
|
8680 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ViSurfaceCreateFlagBitsNN )
|
|
|
8681 {
|
|
|
8682 return "(void)";
|
|
|
8683 }
|
|
|
8684 #endif /*VK_USE_PLATFORM_VI_NN*/
|
|
|
8685
|
|
|
8686 //=== VK_EXT_conditional_rendering ===
|
|
|
8687
|
|
|
8688 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ConditionalRenderingFlagBitsEXT value )
|
|
|
8689 {
|
|
|
8690 switch ( value )
|
|
|
8691 {
|
|
|
8692 case ConditionalRenderingFlagBitsEXT::eInverted: return "Inverted";
|
|
|
8693 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8694 }
|
|
|
8695 }
|
|
|
8696
|
|
|
8697 //=== VK_EXT_display_surface_counter ===
|
|
|
8698
|
|
|
8699 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SurfaceCounterFlagBitsEXT value )
|
|
|
8700 {
|
|
|
8701 switch ( value )
|
|
|
8702 {
|
|
|
8703 case SurfaceCounterFlagBitsEXT::eVblank: return "Vblank";
|
|
|
8704 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8705 }
|
|
|
8706 }
|
|
|
8707
|
|
|
8708 //=== VK_EXT_display_control ===
|
|
|
8709
|
|
|
8710 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DisplayPowerStateEXT value )
|
|
|
8711 {
|
|
|
8712 switch ( value )
|
|
|
8713 {
|
|
|
8714 case DisplayPowerStateEXT::eOff : return "Off";
|
|
|
8715 case DisplayPowerStateEXT::eSuspend: return "Suspend";
|
|
|
8716 case DisplayPowerStateEXT::eOn : return "On";
|
|
|
8717 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8718 }
|
|
|
8719 }
|
|
|
8720
|
|
|
8721 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceEventTypeEXT value )
|
|
|
8722 {
|
|
|
8723 switch ( value )
|
|
|
8724 {
|
|
|
8725 case DeviceEventTypeEXT::eDisplayHotplug: return "DisplayHotplug";
|
|
|
8726 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8727 }
|
|
|
8728 }
|
|
|
8729
|
|
|
8730 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DisplayEventTypeEXT value )
|
|
|
8731 {
|
|
|
8732 switch ( value )
|
|
|
8733 {
|
|
|
8734 case DisplayEventTypeEXT::eFirstPixelOut: return "FirstPixelOut";
|
|
|
8735 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8736 }
|
|
|
8737 }
|
|
|
8738
|
|
|
8739 //=== VK_NV_viewport_swizzle ===
|
|
|
8740
|
|
|
8741 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ViewportCoordinateSwizzleNV value )
|
|
|
8742 {
|
|
|
8743 switch ( value )
|
|
|
8744 {
|
|
|
8745 case ViewportCoordinateSwizzleNV::ePositiveX: return "PositiveX";
|
|
|
8746 case ViewportCoordinateSwizzleNV::eNegativeX: return "NegativeX";
|
|
|
8747 case ViewportCoordinateSwizzleNV::ePositiveY: return "PositiveY";
|
|
|
8748 case ViewportCoordinateSwizzleNV::eNegativeY: return "NegativeY";
|
|
|
8749 case ViewportCoordinateSwizzleNV::ePositiveZ: return "PositiveZ";
|
|
|
8750 case ViewportCoordinateSwizzleNV::eNegativeZ: return "NegativeZ";
|
|
|
8751 case ViewportCoordinateSwizzleNV::ePositiveW: return "PositiveW";
|
|
|
8752 case ViewportCoordinateSwizzleNV::eNegativeW: return "NegativeW";
|
|
|
8753 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8754 }
|
|
|
8755 }
|
|
|
8756
|
|
|
8757 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineViewportSwizzleStateCreateFlagBitsNV )
|
|
|
8758 {
|
|
|
8759 return "(void)";
|
|
|
8760 }
|
|
|
8761
|
|
|
8762 //=== VK_EXT_discard_rectangles ===
|
|
|
8763
|
|
|
8764 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DiscardRectangleModeEXT value )
|
|
|
8765 {
|
|
|
8766 switch ( value )
|
|
|
8767 {
|
|
|
8768 case DiscardRectangleModeEXT::eInclusive: return "Inclusive";
|
|
|
8769 case DiscardRectangleModeEXT::eExclusive: return "Exclusive";
|
|
|
8770 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8771 }
|
|
|
8772 }
|
|
|
8773
|
|
|
8774 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineDiscardRectangleStateCreateFlagBitsEXT )
|
|
|
8775 {
|
|
|
8776 return "(void)";
|
|
|
8777 }
|
|
|
8778
|
|
|
8779 //=== VK_EXT_conservative_rasterization ===
|
|
|
8780
|
|
|
8781 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ConservativeRasterizationModeEXT value )
|
|
|
8782 {
|
|
|
8783 switch ( value )
|
|
|
8784 {
|
|
|
8785 case ConservativeRasterizationModeEXT::eDisabled : return "Disabled";
|
|
|
8786 case ConservativeRasterizationModeEXT::eOverestimate : return "Overestimate";
|
|
|
8787 case ConservativeRasterizationModeEXT::eUnderestimate: return "Underestimate";
|
|
|
8788 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8789 }
|
|
|
8790 }
|
|
|
8791
|
|
|
8792 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRasterizationConservativeStateCreateFlagBitsEXT )
|
|
|
8793 {
|
|
|
8794 return "(void)";
|
|
|
8795 }
|
|
|
8796
|
|
|
8797 //=== VK_EXT_depth_clip_enable ===
|
|
|
8798
|
|
|
8799 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRasterizationDepthClipStateCreateFlagBitsEXT )
|
|
|
8800 {
|
|
|
8801 return "(void)";
|
|
|
8802 }
|
|
|
8803
|
|
|
8804 //=== VK_KHR_performance_query ===
|
|
|
8805
|
|
|
8806 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceCounterDescriptionFlagBitsKHR value )
|
|
|
8807 {
|
|
|
8808 switch ( value )
|
|
|
8809 {
|
|
|
8810 case PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting: return "PerformanceImpacting";
|
|
|
8811 case PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted: return "ConcurrentlyImpacted";
|
|
|
8812 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8813 }
|
|
|
8814 }
|
|
|
8815
|
|
|
8816 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceCounterScopeKHR value )
|
|
|
8817 {
|
|
|
8818 switch ( value )
|
|
|
8819 {
|
|
|
8820 case PerformanceCounterScopeKHR::eCommandBuffer: return "CommandBuffer";
|
|
|
8821 case PerformanceCounterScopeKHR::eRenderPass : return "RenderPass";
|
|
|
8822 case PerformanceCounterScopeKHR::eCommand : return "Command";
|
|
|
8823 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8824 }
|
|
|
8825 }
|
|
|
8826
|
|
|
8827 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceCounterStorageKHR value )
|
|
|
8828 {
|
|
|
8829 switch ( value )
|
|
|
8830 {
|
|
|
8831 case PerformanceCounterStorageKHR::eInt32 : return "Int32";
|
|
|
8832 case PerformanceCounterStorageKHR::eInt64 : return "Int64";
|
|
|
8833 case PerformanceCounterStorageKHR::eUint32 : return "Uint32";
|
|
|
8834 case PerformanceCounterStorageKHR::eUint64 : return "Uint64";
|
|
|
8835 case PerformanceCounterStorageKHR::eFloat32: return "Float32";
|
|
|
8836 case PerformanceCounterStorageKHR::eFloat64: return "Float64";
|
|
|
8837 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8838 }
|
|
|
8839 }
|
|
|
8840
|
|
|
8841 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceCounterUnitKHR value )
|
|
|
8842 {
|
|
|
8843 switch ( value )
|
|
|
8844 {
|
|
|
8845 case PerformanceCounterUnitKHR::eGeneric : return "Generic";
|
|
|
8846 case PerformanceCounterUnitKHR::ePercentage : return "Percentage";
|
|
|
8847 case PerformanceCounterUnitKHR::eNanoseconds : return "Nanoseconds";
|
|
|
8848 case PerformanceCounterUnitKHR::eBytes : return "Bytes";
|
|
|
8849 case PerformanceCounterUnitKHR::eBytesPerSecond: return "BytesPerSecond";
|
|
|
8850 case PerformanceCounterUnitKHR::eKelvin : return "Kelvin";
|
|
|
8851 case PerformanceCounterUnitKHR::eWatts : return "Watts";
|
|
|
8852 case PerformanceCounterUnitKHR::eVolts : return "Volts";
|
|
|
8853 case PerformanceCounterUnitKHR::eAmps : return "Amps";
|
|
|
8854 case PerformanceCounterUnitKHR::eHertz : return "Hertz";
|
|
|
8855 case PerformanceCounterUnitKHR::eCycles : return "Cycles";
|
|
|
8856 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8857 }
|
|
|
8858 }
|
|
|
8859
|
|
|
8860 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AcquireProfilingLockFlagBitsKHR )
|
|
|
8861 {
|
|
|
8862 return "(void)";
|
|
|
8863 }
|
|
|
8864
|
|
|
8865 #if defined( VK_USE_PLATFORM_IOS_MVK )
|
|
|
8866 //=== VK_MVK_ios_surface ===
|
|
|
8867
|
|
|
8868 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IOSSurfaceCreateFlagBitsMVK )
|
|
|
8869 {
|
|
|
8870 return "(void)";
|
|
|
8871 }
|
|
|
8872 #endif /*VK_USE_PLATFORM_IOS_MVK*/
|
|
|
8873
|
|
|
8874 #if defined( VK_USE_PLATFORM_MACOS_MVK )
|
|
|
8875 //=== VK_MVK_macos_surface ===
|
|
|
8876
|
|
|
8877 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MacOSSurfaceCreateFlagBitsMVK )
|
|
|
8878 {
|
|
|
8879 return "(void)";
|
|
|
8880 }
|
|
|
8881 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
|
|
|
8882
|
|
|
8883 //=== VK_EXT_debug_utils ===
|
|
|
8884
|
|
|
8885 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DebugUtilsMessageSeverityFlagBitsEXT value )
|
|
|
8886 {
|
|
|
8887 switch ( value )
|
|
|
8888 {
|
|
|
8889 case DebugUtilsMessageSeverityFlagBitsEXT::eVerbose: return "Verbose";
|
|
|
8890 case DebugUtilsMessageSeverityFlagBitsEXT::eInfo : return "Info";
|
|
|
8891 case DebugUtilsMessageSeverityFlagBitsEXT::eWarning: return "Warning";
|
|
|
8892 case DebugUtilsMessageSeverityFlagBitsEXT::eError : return "Error";
|
|
|
8893 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8894 }
|
|
|
8895 }
|
|
|
8896
|
|
|
8897 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DebugUtilsMessageTypeFlagBitsEXT value )
|
|
|
8898 {
|
|
|
8899 switch ( value )
|
|
|
8900 {
|
|
|
8901 case DebugUtilsMessageTypeFlagBitsEXT::eGeneral : return "General";
|
|
|
8902 case DebugUtilsMessageTypeFlagBitsEXT::eValidation : return "Validation";
|
|
|
8903 case DebugUtilsMessageTypeFlagBitsEXT::ePerformance : return "Performance";
|
|
|
8904 case DebugUtilsMessageTypeFlagBitsEXT::eDeviceAddressBinding: return "DeviceAddressBinding";
|
|
|
8905 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8906 }
|
|
|
8907 }
|
|
|
8908
|
|
|
8909 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DebugUtilsMessengerCallbackDataFlagBitsEXT )
|
|
|
8910 {
|
|
|
8911 return "(void)";
|
|
|
8912 }
|
|
|
8913
|
|
|
8914 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DebugUtilsMessengerCreateFlagBitsEXT )
|
|
|
8915 {
|
|
|
8916 return "(void)";
|
|
|
8917 }
|
|
|
8918
|
|
|
8919 //=== VK_EXT_blend_operation_advanced ===
|
|
|
8920
|
|
|
8921 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BlendOverlapEXT value )
|
|
|
8922 {
|
|
|
8923 switch ( value )
|
|
|
8924 {
|
|
|
8925 case BlendOverlapEXT::eUncorrelated: return "Uncorrelated";
|
|
|
8926 case BlendOverlapEXT::eDisjoint : return "Disjoint";
|
|
|
8927 case BlendOverlapEXT::eConjoint : return "Conjoint";
|
|
|
8928 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8929 }
|
|
|
8930 }
|
|
|
8931
|
|
|
8932 //=== VK_NV_fragment_coverage_to_color ===
|
|
|
8933
|
|
|
8934 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCoverageToColorStateCreateFlagBitsNV )
|
|
|
8935 {
|
|
|
8936 return "(void)";
|
|
|
8937 }
|
|
|
8938
|
|
|
8939 //=== VK_KHR_acceleration_structure ===
|
|
|
8940
|
|
|
8941 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureTypeKHR value )
|
|
|
8942 {
|
|
|
8943 switch ( value )
|
|
|
8944 {
|
|
|
8945 case AccelerationStructureTypeKHR::eTopLevel : return "TopLevel";
|
|
|
8946 case AccelerationStructureTypeKHR::eBottomLevel: return "BottomLevel";
|
|
|
8947 case AccelerationStructureTypeKHR::eGeneric : return "Generic";
|
|
|
8948 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8949 }
|
|
|
8950 }
|
|
|
8951
|
|
|
8952 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureBuildTypeKHR value )
|
|
|
8953 {
|
|
|
8954 switch ( value )
|
|
|
8955 {
|
|
|
8956 case AccelerationStructureBuildTypeKHR::eHost : return "Host";
|
|
|
8957 case AccelerationStructureBuildTypeKHR::eDevice : return "Device";
|
|
|
8958 case AccelerationStructureBuildTypeKHR::eHostOrDevice: return "HostOrDevice";
|
|
|
8959 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8960 }
|
|
|
8961 }
|
|
|
8962
|
|
|
8963 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( GeometryFlagBitsKHR value )
|
|
|
8964 {
|
|
|
8965 switch ( value )
|
|
|
8966 {
|
|
|
8967 case GeometryFlagBitsKHR::eOpaque : return "Opaque";
|
|
|
8968 case GeometryFlagBitsKHR::eNoDuplicateAnyHitInvocation: return "NoDuplicateAnyHitInvocation";
|
|
|
8969 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8970 }
|
|
|
8971 }
|
|
|
8972
|
|
|
8973 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( GeometryInstanceFlagBitsKHR value )
|
|
|
8974 {
|
|
|
8975 switch ( value )
|
|
|
8976 {
|
|
|
8977 case GeometryInstanceFlagBitsKHR::eTriangleFacingCullDisable : return "TriangleFacingCullDisable";
|
|
|
8978 case GeometryInstanceFlagBitsKHR::eTriangleFlipFacing : return "TriangleFlipFacing";
|
|
|
8979 case GeometryInstanceFlagBitsKHR::eForceOpaque : return "ForceOpaque";
|
|
|
8980 case GeometryInstanceFlagBitsKHR::eForceNoOpaque : return "ForceNoOpaque";
|
|
|
8981 case GeometryInstanceFlagBitsKHR::eForceOpacityMicromap2StateEXT: return "ForceOpacityMicromap2StateEXT";
|
|
|
8982 case GeometryInstanceFlagBitsKHR::eDisableOpacityMicromapsEXT : return "DisableOpacityMicromapsEXT";
|
|
|
8983 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
8984 }
|
|
|
8985 }
|
|
|
8986
|
|
|
8987 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BuildAccelerationStructureFlagBitsKHR value )
|
|
|
8988 {
|
|
|
8989 switch ( value )
|
|
|
8990 {
|
|
|
8991 case BuildAccelerationStructureFlagBitsKHR::eAllowUpdate : return "AllowUpdate";
|
|
|
8992 case BuildAccelerationStructureFlagBitsKHR::eAllowCompaction : return "AllowCompaction";
|
|
|
8993 case BuildAccelerationStructureFlagBitsKHR::ePreferFastTrace : return "PreferFastTrace";
|
|
|
8994 case BuildAccelerationStructureFlagBitsKHR::ePreferFastBuild : return "PreferFastBuild";
|
|
|
8995 case BuildAccelerationStructureFlagBitsKHR::eLowMemory : return "LowMemory";
|
|
|
8996 case BuildAccelerationStructureFlagBitsKHR::eMotionNV : return "MotionNV";
|
|
|
8997 case BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapUpdateEXT : return "AllowOpacityMicromapUpdateEXT";
|
|
|
8998 case BuildAccelerationStructureFlagBitsKHR::eAllowDisableOpacityMicromapsEXT : return "AllowDisableOpacityMicromapsEXT";
|
|
|
8999 case BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapDataUpdateEXT: return "AllowOpacityMicromapDataUpdateEXT";
|
|
|
9000 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
9001 case BuildAccelerationStructureFlagBitsKHR::eAllowDisplacementMicromapUpdateNV: return "AllowDisplacementMicromapUpdateNV";
|
|
|
9002 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
9003 case BuildAccelerationStructureFlagBitsKHR::eAllowDataAccess : return "AllowDataAccess";
|
|
|
9004 case BuildAccelerationStructureFlagBitsKHR::eAllowClusterOpacityMicromapsNV: return "AllowClusterOpacityMicromapsNV";
|
|
|
9005 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9006 }
|
|
|
9007 }
|
|
|
9008
|
|
|
9009 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CopyAccelerationStructureModeKHR value )
|
|
|
9010 {
|
|
|
9011 switch ( value )
|
|
|
9012 {
|
|
|
9013 case CopyAccelerationStructureModeKHR::eClone : return "Clone";
|
|
|
9014 case CopyAccelerationStructureModeKHR::eCompact : return "Compact";
|
|
|
9015 case CopyAccelerationStructureModeKHR::eSerialize : return "Serialize";
|
|
|
9016 case CopyAccelerationStructureModeKHR::eDeserialize: return "Deserialize";
|
|
|
9017 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9018 }
|
|
|
9019 }
|
|
|
9020
|
|
|
9021 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( GeometryTypeKHR value )
|
|
|
9022 {
|
|
|
9023 switch ( value )
|
|
|
9024 {
|
|
|
9025 case GeometryTypeKHR::eTriangles : return "Triangles";
|
|
|
9026 case GeometryTypeKHR::eAabbs : return "Aabbs";
|
|
|
9027 case GeometryTypeKHR::eInstances : return "Instances";
|
|
|
9028 case GeometryTypeKHR::eSpheresNV : return "SpheresNV";
|
|
|
9029 case GeometryTypeKHR::eLinearSweptSpheresNV: return "LinearSweptSpheresNV";
|
|
|
9030 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
9031 case GeometryTypeKHR::eDenseGeometryFormatTrianglesAMDX: return "DenseGeometryFormatTrianglesAMDX";
|
|
|
9032 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
9033 default: return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9034 }
|
|
|
9035 }
|
|
|
9036
|
|
|
9037 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureCompatibilityKHR value )
|
|
|
9038 {
|
|
|
9039 switch ( value )
|
|
|
9040 {
|
|
|
9041 case AccelerationStructureCompatibilityKHR::eCompatible : return "Compatible";
|
|
|
9042 case AccelerationStructureCompatibilityKHR::eIncompatible: return "Incompatible";
|
|
|
9043 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9044 }
|
|
|
9045 }
|
|
|
9046
|
|
|
9047 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureCreateFlagBitsKHR value )
|
|
|
9048 {
|
|
|
9049 switch ( value )
|
|
|
9050 {
|
|
|
9051 case AccelerationStructureCreateFlagBitsKHR::eDeviceAddressCaptureReplay : return "DeviceAddressCaptureReplay";
|
|
|
9052 case AccelerationStructureCreateFlagBitsKHR::eDescriptorBufferCaptureReplayEXT: return "DescriptorBufferCaptureReplayEXT";
|
|
|
9053 case AccelerationStructureCreateFlagBitsKHR::eMotionNV : return "MotionNV";
|
|
|
9054 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9055 }
|
|
|
9056 }
|
|
|
9057
|
|
|
9058 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BuildAccelerationStructureModeKHR value )
|
|
|
9059 {
|
|
|
9060 switch ( value )
|
|
|
9061 {
|
|
|
9062 case BuildAccelerationStructureModeKHR::eBuild : return "Build";
|
|
|
9063 case BuildAccelerationStructureModeKHR::eUpdate: return "Update";
|
|
|
9064 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9065 }
|
|
|
9066 }
|
|
|
9067
|
|
|
9068 //=== VK_KHR_ray_tracing_pipeline ===
|
|
|
9069
|
|
|
9070 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( RayTracingShaderGroupTypeKHR value )
|
|
|
9071 {
|
|
|
9072 switch ( value )
|
|
|
9073 {
|
|
|
9074 case RayTracingShaderGroupTypeKHR::eGeneral : return "General";
|
|
|
9075 case RayTracingShaderGroupTypeKHR::eTrianglesHitGroup : return "TrianglesHitGroup";
|
|
|
9076 case RayTracingShaderGroupTypeKHR::eProceduralHitGroup: return "ProceduralHitGroup";
|
|
|
9077 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9078 }
|
|
|
9079 }
|
|
|
9080
|
|
|
9081 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderGroupShaderKHR value )
|
|
|
9082 {
|
|
|
9083 switch ( value )
|
|
|
9084 {
|
|
|
9085 case ShaderGroupShaderKHR::eGeneral : return "General";
|
|
|
9086 case ShaderGroupShaderKHR::eClosestHit : return "ClosestHit";
|
|
|
9087 case ShaderGroupShaderKHR::eAnyHit : return "AnyHit";
|
|
|
9088 case ShaderGroupShaderKHR::eIntersection: return "Intersection";
|
|
|
9089 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9090 }
|
|
|
9091 }
|
|
|
9092
|
|
|
9093 //=== VK_NV_framebuffer_mixed_samples ===
|
|
|
9094
|
|
|
9095 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CoverageModulationModeNV value )
|
|
|
9096 {
|
|
|
9097 switch ( value )
|
|
|
9098 {
|
|
|
9099 case CoverageModulationModeNV::eNone : return "None";
|
|
|
9100 case CoverageModulationModeNV::eRgb : return "Rgb";
|
|
|
9101 case CoverageModulationModeNV::eAlpha: return "Alpha";
|
|
|
9102 case CoverageModulationModeNV::eRgba : return "Rgba";
|
|
|
9103 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9104 }
|
|
|
9105 }
|
|
|
9106
|
|
|
9107 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCoverageModulationStateCreateFlagBitsNV )
|
|
|
9108 {
|
|
|
9109 return "(void)";
|
|
|
9110 }
|
|
|
9111
|
|
|
9112 //=== VK_EXT_validation_cache ===
|
|
|
9113
|
|
|
9114 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ValidationCacheHeaderVersionEXT value )
|
|
|
9115 {
|
|
|
9116 switch ( value )
|
|
|
9117 {
|
|
|
9118 case ValidationCacheHeaderVersionEXT::eOne: return "One";
|
|
|
9119 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9120 }
|
|
|
9121 }
|
|
|
9122
|
|
|
9123 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ValidationCacheCreateFlagBitsEXT )
|
|
|
9124 {
|
|
|
9125 return "(void)";
|
|
|
9126 }
|
|
|
9127
|
|
|
9128 //=== VK_NV_shading_rate_image ===
|
|
|
9129
|
|
|
9130 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShadingRatePaletteEntryNV value )
|
|
|
9131 {
|
|
|
9132 switch ( value )
|
|
|
9133 {
|
|
|
9134 case ShadingRatePaletteEntryNV::eNoInvocations : return "NoInvocations";
|
|
|
9135 case ShadingRatePaletteEntryNV::e16InvocationsPerPixel : return "16InvocationsPerPixel";
|
|
|
9136 case ShadingRatePaletteEntryNV::e8InvocationsPerPixel : return "8InvocationsPerPixel";
|
|
|
9137 case ShadingRatePaletteEntryNV::e4InvocationsPerPixel : return "4InvocationsPerPixel";
|
|
|
9138 case ShadingRatePaletteEntryNV::e2InvocationsPerPixel : return "2InvocationsPerPixel";
|
|
|
9139 case ShadingRatePaletteEntryNV::e1InvocationPerPixel : return "1InvocationPerPixel";
|
|
|
9140 case ShadingRatePaletteEntryNV::e1InvocationPer2X1Pixels: return "1InvocationPer2X1Pixels";
|
|
|
9141 case ShadingRatePaletteEntryNV::e1InvocationPer1X2Pixels: return "1InvocationPer1X2Pixels";
|
|
|
9142 case ShadingRatePaletteEntryNV::e1InvocationPer2X2Pixels: return "1InvocationPer2X2Pixels";
|
|
|
9143 case ShadingRatePaletteEntryNV::e1InvocationPer4X2Pixels: return "1InvocationPer4X2Pixels";
|
|
|
9144 case ShadingRatePaletteEntryNV::e1InvocationPer2X4Pixels: return "1InvocationPer2X4Pixels";
|
|
|
9145 case ShadingRatePaletteEntryNV::e1InvocationPer4X4Pixels: return "1InvocationPer4X4Pixels";
|
|
|
9146 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9147 }
|
|
|
9148 }
|
|
|
9149
|
|
|
9150 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CoarseSampleOrderTypeNV value )
|
|
|
9151 {
|
|
|
9152 switch ( value )
|
|
|
9153 {
|
|
|
9154 case CoarseSampleOrderTypeNV::eDefault : return "Default";
|
|
|
9155 case CoarseSampleOrderTypeNV::eCustom : return "Custom";
|
|
|
9156 case CoarseSampleOrderTypeNV::ePixelMajor : return "PixelMajor";
|
|
|
9157 case CoarseSampleOrderTypeNV::eSampleMajor: return "SampleMajor";
|
|
|
9158 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9159 }
|
|
|
9160 }
|
|
|
9161
|
|
|
9162 //=== VK_NV_ray_tracing ===
|
|
|
9163
|
|
|
9164 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureMemoryRequirementsTypeNV value )
|
|
|
9165 {
|
|
|
9166 switch ( value )
|
|
|
9167 {
|
|
|
9168 case AccelerationStructureMemoryRequirementsTypeNV::eObject : return "Object";
|
|
|
9169 case AccelerationStructureMemoryRequirementsTypeNV::eBuildScratch : return "BuildScratch";
|
|
|
9170 case AccelerationStructureMemoryRequirementsTypeNV::eUpdateScratch: return "UpdateScratch";
|
|
|
9171 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9172 }
|
|
|
9173 }
|
|
|
9174
|
|
|
9175 //=== VK_AMD_pipeline_compiler_control ===
|
|
|
9176
|
|
|
9177 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCompilerControlFlagBitsAMD )
|
|
|
9178 {
|
|
|
9179 return "(void)";
|
|
|
9180 }
|
|
|
9181
|
|
|
9182 //=== VK_AMD_memory_overallocation_behavior ===
|
|
|
9183
|
|
|
9184 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MemoryOverallocationBehaviorAMD value )
|
|
|
9185 {
|
|
|
9186 switch ( value )
|
|
|
9187 {
|
|
|
9188 case MemoryOverallocationBehaviorAMD::eDefault : return "Default";
|
|
|
9189 case MemoryOverallocationBehaviorAMD::eAllowed : return "Allowed";
|
|
|
9190 case MemoryOverallocationBehaviorAMD::eDisallowed: return "Disallowed";
|
|
|
9191 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9192 }
|
|
|
9193 }
|
|
|
9194
|
|
|
9195 //=== VK_INTEL_performance_query ===
|
|
|
9196
|
|
|
9197 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceConfigurationTypeINTEL value )
|
|
|
9198 {
|
|
|
9199 switch ( value )
|
|
|
9200 {
|
|
|
9201 case PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated: return "CommandQueueMetricsDiscoveryActivated";
|
|
|
9202 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9203 }
|
|
|
9204 }
|
|
|
9205
|
|
|
9206 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( QueryPoolSamplingModeINTEL value )
|
|
|
9207 {
|
|
|
9208 switch ( value )
|
|
|
9209 {
|
|
|
9210 case QueryPoolSamplingModeINTEL::eManual: return "Manual";
|
|
|
9211 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9212 }
|
|
|
9213 }
|
|
|
9214
|
|
|
9215 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceOverrideTypeINTEL value )
|
|
|
9216 {
|
|
|
9217 switch ( value )
|
|
|
9218 {
|
|
|
9219 case PerformanceOverrideTypeINTEL::eNullHardware : return "NullHardware";
|
|
|
9220 case PerformanceOverrideTypeINTEL::eFlushGpuCaches: return "FlushGpuCaches";
|
|
|
9221 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9222 }
|
|
|
9223 }
|
|
|
9224
|
|
|
9225 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceParameterTypeINTEL value )
|
|
|
9226 {
|
|
|
9227 switch ( value )
|
|
|
9228 {
|
|
|
9229 case PerformanceParameterTypeINTEL::eHwCountersSupported : return "HwCountersSupported";
|
|
|
9230 case PerformanceParameterTypeINTEL::eStreamMarkerValidBits: return "StreamMarkerValidBits";
|
|
|
9231 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9232 }
|
|
|
9233 }
|
|
|
9234
|
|
|
9235 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceValueTypeINTEL value )
|
|
|
9236 {
|
|
|
9237 switch ( value )
|
|
|
9238 {
|
|
|
9239 case PerformanceValueTypeINTEL::eUint32: return "Uint32";
|
|
|
9240 case PerformanceValueTypeINTEL::eUint64: return "Uint64";
|
|
|
9241 case PerformanceValueTypeINTEL::eFloat : return "Float";
|
|
|
9242 case PerformanceValueTypeINTEL::eBool : return "Bool";
|
|
|
9243 case PerformanceValueTypeINTEL::eString: return "String";
|
|
|
9244 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9245 }
|
|
|
9246 }
|
|
|
9247
|
|
|
9248 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
9249 //=== VK_FUCHSIA_imagepipe_surface ===
|
|
|
9250
|
|
|
9251 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImagePipeSurfaceCreateFlagBitsFUCHSIA )
|
|
|
9252 {
|
|
|
9253 return "(void)";
|
|
|
9254 }
|
|
|
9255 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
9256
|
|
|
9257 #if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
9258 //=== VK_EXT_metal_surface ===
|
|
|
9259
|
|
|
9260 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MetalSurfaceCreateFlagBitsEXT )
|
|
|
9261 {
|
|
|
9262 return "(void)";
|
|
|
9263 }
|
|
|
9264 #endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
9265
|
|
|
9266 //=== VK_KHR_fragment_shading_rate ===
|
|
|
9267
|
|
|
9268 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FragmentShadingRateCombinerOpKHR value )
|
|
|
9269 {
|
|
|
9270 switch ( value )
|
|
|
9271 {
|
|
|
9272 case FragmentShadingRateCombinerOpKHR::eKeep : return "Keep";
|
|
|
9273 case FragmentShadingRateCombinerOpKHR::eReplace: return "Replace";
|
|
|
9274 case FragmentShadingRateCombinerOpKHR::eMin : return "Min";
|
|
|
9275 case FragmentShadingRateCombinerOpKHR::eMax : return "Max";
|
|
|
9276 case FragmentShadingRateCombinerOpKHR::eMul : return "Mul";
|
|
|
9277 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9278 }
|
|
|
9279 }
|
|
|
9280
|
|
|
9281 //=== VK_AMD_shader_core_properties2 ===
|
|
|
9282
|
|
|
9283 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderCorePropertiesFlagBitsAMD )
|
|
|
9284 {
|
|
|
9285 return "(void)";
|
|
|
9286 }
|
|
|
9287
|
|
|
9288 //=== VK_EXT_validation_features ===
|
|
|
9289
|
|
|
9290 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ValidationFeatureEnableEXT value )
|
|
|
9291 {
|
|
|
9292 switch ( value )
|
|
|
9293 {
|
|
|
9294 case ValidationFeatureEnableEXT::eGpuAssisted : return "GpuAssisted";
|
|
|
9295 case ValidationFeatureEnableEXT::eGpuAssistedReserveBindingSlot: return "GpuAssistedReserveBindingSlot";
|
|
|
9296 case ValidationFeatureEnableEXT::eBestPractices : return "BestPractices";
|
|
|
9297 case ValidationFeatureEnableEXT::eDebugPrintf : return "DebugPrintf";
|
|
|
9298 case ValidationFeatureEnableEXT::eSynchronizationValidation : return "SynchronizationValidation";
|
|
|
9299 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9300 }
|
|
|
9301 }
|
|
|
9302
|
|
|
9303 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ValidationFeatureDisableEXT value )
|
|
|
9304 {
|
|
|
9305 switch ( value )
|
|
|
9306 {
|
|
|
9307 case ValidationFeatureDisableEXT::eAll : return "All";
|
|
|
9308 case ValidationFeatureDisableEXT::eShaders : return "Shaders";
|
|
|
9309 case ValidationFeatureDisableEXT::eThreadSafety : return "ThreadSafety";
|
|
|
9310 case ValidationFeatureDisableEXT::eApiParameters : return "ApiParameters";
|
|
|
9311 case ValidationFeatureDisableEXT::eObjectLifetimes : return "ObjectLifetimes";
|
|
|
9312 case ValidationFeatureDisableEXT::eCoreChecks : return "CoreChecks";
|
|
|
9313 case ValidationFeatureDisableEXT::eUniqueHandles : return "UniqueHandles";
|
|
|
9314 case ValidationFeatureDisableEXT::eShaderValidationCache: return "ShaderValidationCache";
|
|
|
9315 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9316 }
|
|
|
9317 }
|
|
|
9318
|
|
|
9319 //=== VK_NV_coverage_reduction_mode ===
|
|
|
9320
|
|
|
9321 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CoverageReductionModeNV value )
|
|
|
9322 {
|
|
|
9323 switch ( value )
|
|
|
9324 {
|
|
|
9325 case CoverageReductionModeNV::eMerge : return "Merge";
|
|
|
9326 case CoverageReductionModeNV::eTruncate: return "Truncate";
|
|
|
9327 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9328 }
|
|
|
9329 }
|
|
|
9330
|
|
|
9331 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCoverageReductionStateCreateFlagBitsNV )
|
|
|
9332 {
|
|
|
9333 return "(void)";
|
|
|
9334 }
|
|
|
9335
|
|
|
9336 //=== VK_EXT_provoking_vertex ===
|
|
|
9337
|
|
|
9338 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ProvokingVertexModeEXT value )
|
|
|
9339 {
|
|
|
9340 switch ( value )
|
|
|
9341 {
|
|
|
9342 case ProvokingVertexModeEXT::eFirstVertex: return "FirstVertex";
|
|
|
9343 case ProvokingVertexModeEXT::eLastVertex : return "LastVertex";
|
|
|
9344 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9345 }
|
|
|
9346 }
|
|
|
9347
|
|
|
9348 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
9349 //=== VK_EXT_full_screen_exclusive ===
|
|
|
9350
|
|
|
9351 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FullScreenExclusiveEXT value )
|
|
|
9352 {
|
|
|
9353 switch ( value )
|
|
|
9354 {
|
|
|
9355 case FullScreenExclusiveEXT::eDefault : return "Default";
|
|
|
9356 case FullScreenExclusiveEXT::eAllowed : return "Allowed";
|
|
|
9357 case FullScreenExclusiveEXT::eDisallowed : return "Disallowed";
|
|
|
9358 case FullScreenExclusiveEXT::eApplicationControlled: return "ApplicationControlled";
|
|
|
9359 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9360 }
|
|
|
9361 }
|
|
|
9362 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
9363
|
|
|
9364 //=== VK_EXT_headless_surface ===
|
|
|
9365
|
|
|
9366 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( HeadlessSurfaceCreateFlagBitsEXT )
|
|
|
9367 {
|
|
|
9368 return "(void)";
|
|
|
9369 }
|
|
|
9370
|
|
|
9371 //=== VK_KHR_pipeline_executable_properties ===
|
|
|
9372
|
|
|
9373 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineExecutableStatisticFormatKHR value )
|
|
|
9374 {
|
|
|
9375 switch ( value )
|
|
|
9376 {
|
|
|
9377 case PipelineExecutableStatisticFormatKHR::eBool32 : return "Bool32";
|
|
|
9378 case PipelineExecutableStatisticFormatKHR::eInt64 : return "Int64";
|
|
|
9379 case PipelineExecutableStatisticFormatKHR::eUint64 : return "Uint64";
|
|
|
9380 case PipelineExecutableStatisticFormatKHR::eFloat64: return "Float64";
|
|
|
9381 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9382 }
|
|
|
9383 }
|
|
|
9384
|
|
|
9385 //=== VK_NV_device_generated_commands ===
|
|
|
9386
|
|
|
9387 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IndirectStateFlagBitsNV value )
|
|
|
9388 {
|
|
|
9389 switch ( value )
|
|
|
9390 {
|
|
|
9391 case IndirectStateFlagBitsNV::eFlagFrontface: return "FlagFrontface";
|
|
|
9392 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9393 }
|
|
|
9394 }
|
|
|
9395
|
|
|
9396 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IndirectCommandsTokenTypeNV value )
|
|
|
9397 {
|
|
|
9398 switch ( value )
|
|
|
9399 {
|
|
|
9400 case IndirectCommandsTokenTypeNV::eShaderGroup : return "ShaderGroup";
|
|
|
9401 case IndirectCommandsTokenTypeNV::eStateFlags : return "StateFlags";
|
|
|
9402 case IndirectCommandsTokenTypeNV::eIndexBuffer : return "IndexBuffer";
|
|
|
9403 case IndirectCommandsTokenTypeNV::eVertexBuffer : return "VertexBuffer";
|
|
|
9404 case IndirectCommandsTokenTypeNV::ePushConstant : return "PushConstant";
|
|
|
9405 case IndirectCommandsTokenTypeNV::eDrawIndexed : return "DrawIndexed";
|
|
|
9406 case IndirectCommandsTokenTypeNV::eDraw : return "Draw";
|
|
|
9407 case IndirectCommandsTokenTypeNV::eDrawTasks : return "DrawTasks";
|
|
|
9408 case IndirectCommandsTokenTypeNV::eDrawMeshTasks: return "DrawMeshTasks";
|
|
|
9409 case IndirectCommandsTokenTypeNV::ePipeline : return "Pipeline";
|
|
|
9410 case IndirectCommandsTokenTypeNV::eDispatch : return "Dispatch";
|
|
|
9411 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9412 }
|
|
|
9413 }
|
|
|
9414
|
|
|
9415 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IndirectCommandsLayoutUsageFlagBitsNV value )
|
|
|
9416 {
|
|
|
9417 switch ( value )
|
|
|
9418 {
|
|
|
9419 case IndirectCommandsLayoutUsageFlagBitsNV::eExplicitPreprocess: return "ExplicitPreprocess";
|
|
|
9420 case IndirectCommandsLayoutUsageFlagBitsNV::eIndexedSequences : return "IndexedSequences";
|
|
|
9421 case IndirectCommandsLayoutUsageFlagBitsNV::eUnorderedSequences: return "UnorderedSequences";
|
|
|
9422 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9423 }
|
|
|
9424 }
|
|
|
9425
|
|
|
9426 //=== VK_EXT_depth_bias_control ===
|
|
|
9427
|
|
|
9428 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DepthBiasRepresentationEXT value )
|
|
|
9429 {
|
|
|
9430 switch ( value )
|
|
|
9431 {
|
|
|
9432 case DepthBiasRepresentationEXT::eLeastRepresentableValueFormat : return "LeastRepresentableValueFormat";
|
|
|
9433 case DepthBiasRepresentationEXT::eLeastRepresentableValueForceUnorm: return "LeastRepresentableValueForceUnorm";
|
|
|
9434 case DepthBiasRepresentationEXT::eFloat : return "Float";
|
|
|
9435 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9436 }
|
|
|
9437 }
|
|
|
9438
|
|
|
9439 //=== VK_EXT_device_memory_report ===
|
|
|
9440
|
|
|
9441 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceMemoryReportEventTypeEXT value )
|
|
|
9442 {
|
|
|
9443 switch ( value )
|
|
|
9444 {
|
|
|
9445 case DeviceMemoryReportEventTypeEXT::eAllocate : return "Allocate";
|
|
|
9446 case DeviceMemoryReportEventTypeEXT::eFree : return "Free";
|
|
|
9447 case DeviceMemoryReportEventTypeEXT::eImport : return "Import";
|
|
|
9448 case DeviceMemoryReportEventTypeEXT::eUnimport : return "Unimport";
|
|
|
9449 case DeviceMemoryReportEventTypeEXT::eAllocationFailed: return "AllocationFailed";
|
|
|
9450 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9451 }
|
|
|
9452 }
|
|
|
9453
|
|
|
9454 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceMemoryReportFlagBitsEXT )
|
|
|
9455 {
|
|
|
9456 return "(void)";
|
|
|
9457 }
|
|
|
9458
|
|
|
9459 //=== VK_KHR_video_encode_queue ===
|
|
|
9460
|
|
|
9461 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeCapabilityFlagBitsKHR value )
|
|
|
9462 {
|
|
|
9463 switch ( value )
|
|
|
9464 {
|
|
|
9465 case VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes : return "PrecedingExternallyEncodedBytes";
|
|
|
9466 case VideoEncodeCapabilityFlagBitsKHR::eInsufficientBitstreamBufferRangeDetection: return "InsufficientBitstreamBufferRangeDetection";
|
|
|
9467 case VideoEncodeCapabilityFlagBitsKHR::eQuantizationDeltaMap : return "QuantizationDeltaMap";
|
|
|
9468 case VideoEncodeCapabilityFlagBitsKHR::eEmphasisMap : return "EmphasisMap";
|
|
|
9469 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9470 }
|
|
|
9471 }
|
|
|
9472
|
|
|
9473 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeFeedbackFlagBitsKHR value )
|
|
|
9474 {
|
|
|
9475 switch ( value )
|
|
|
9476 {
|
|
|
9477 case VideoEncodeFeedbackFlagBitsKHR::eBitstreamBufferOffset: return "BitstreamBufferOffset";
|
|
|
9478 case VideoEncodeFeedbackFlagBitsKHR::eBitstreamBytesWritten: return "BitstreamBytesWritten";
|
|
|
9479 case VideoEncodeFeedbackFlagBitsKHR::eBitstreamHasOverrides: return "BitstreamHasOverrides";
|
|
|
9480 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9481 }
|
|
|
9482 }
|
|
|
9483
|
|
|
9484 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeUsageFlagBitsKHR value )
|
|
|
9485 {
|
|
|
9486 switch ( value )
|
|
|
9487 {
|
|
|
9488 case VideoEncodeUsageFlagBitsKHR::eDefault : return "Default";
|
|
|
9489 case VideoEncodeUsageFlagBitsKHR::eTranscoding : return "Transcoding";
|
|
|
9490 case VideoEncodeUsageFlagBitsKHR::eStreaming : return "Streaming";
|
|
|
9491 case VideoEncodeUsageFlagBitsKHR::eRecording : return "Recording";
|
|
|
9492 case VideoEncodeUsageFlagBitsKHR::eConferencing: return "Conferencing";
|
|
|
9493 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9494 }
|
|
|
9495 }
|
|
|
9496
|
|
|
9497 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeContentFlagBitsKHR value )
|
|
|
9498 {
|
|
|
9499 switch ( value )
|
|
|
9500 {
|
|
|
9501 case VideoEncodeContentFlagBitsKHR::eDefault : return "Default";
|
|
|
9502 case VideoEncodeContentFlagBitsKHR::eCamera : return "Camera";
|
|
|
9503 case VideoEncodeContentFlagBitsKHR::eDesktop : return "Desktop";
|
|
|
9504 case VideoEncodeContentFlagBitsKHR::eRendered: return "Rendered";
|
|
|
9505 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9506 }
|
|
|
9507 }
|
|
|
9508
|
|
|
9509 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeTuningModeKHR value )
|
|
|
9510 {
|
|
|
9511 switch ( value )
|
|
|
9512 {
|
|
|
9513 case VideoEncodeTuningModeKHR::eDefault : return "Default";
|
|
|
9514 case VideoEncodeTuningModeKHR::eHighQuality : return "HighQuality";
|
|
|
9515 case VideoEncodeTuningModeKHR::eLowLatency : return "LowLatency";
|
|
|
9516 case VideoEncodeTuningModeKHR::eUltraLowLatency: return "UltraLowLatency";
|
|
|
9517 case VideoEncodeTuningModeKHR::eLossless : return "Lossless";
|
|
|
9518 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9519 }
|
|
|
9520 }
|
|
|
9521
|
|
|
9522 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeRateControlModeFlagBitsKHR value )
|
|
|
9523 {
|
|
|
9524 switch ( value )
|
|
|
9525 {
|
|
|
9526 case VideoEncodeRateControlModeFlagBitsKHR::eDefault : return "Default";
|
|
|
9527 case VideoEncodeRateControlModeFlagBitsKHR::eDisabled: return "Disabled";
|
|
|
9528 case VideoEncodeRateControlModeFlagBitsKHR::eCbr : return "Cbr";
|
|
|
9529 case VideoEncodeRateControlModeFlagBitsKHR::eVbr : return "Vbr";
|
|
|
9530 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9531 }
|
|
|
9532 }
|
|
|
9533
|
|
|
9534 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeFlagBitsKHR value )
|
|
|
9535 {
|
|
|
9536 switch ( value )
|
|
|
9537 {
|
|
|
9538 case VideoEncodeFlagBitsKHR::eIntraRefresh : return "IntraRefresh";
|
|
|
9539 case VideoEncodeFlagBitsKHR::eWithQuantizationDeltaMap: return "WithQuantizationDeltaMap";
|
|
|
9540 case VideoEncodeFlagBitsKHR::eWithEmphasisMap : return "WithEmphasisMap";
|
|
|
9541 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9542 }
|
|
|
9543 }
|
|
|
9544
|
|
|
9545 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeRateControlFlagBitsKHR )
|
|
|
9546 {
|
|
|
9547 return "(void)";
|
|
|
9548 }
|
|
|
9549
|
|
|
9550 //=== VK_NV_device_diagnostics_config ===
|
|
|
9551
|
|
|
9552 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceDiagnosticsConfigFlagBitsNV value )
|
|
|
9553 {
|
|
|
9554 switch ( value )
|
|
|
9555 {
|
|
|
9556 case DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderDebugInfo : return "EnableShaderDebugInfo";
|
|
|
9557 case DeviceDiagnosticsConfigFlagBitsNV::eEnableResourceTracking : return "EnableResourceTracking";
|
|
|
9558 case DeviceDiagnosticsConfigFlagBitsNV::eEnableAutomaticCheckpoints: return "EnableAutomaticCheckpoints";
|
|
|
9559 case DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderErrorReporting: return "EnableShaderErrorReporting";
|
|
|
9560 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9561 }
|
|
|
9562 }
|
|
|
9563
|
|
|
9564 //=== VK_QCOM_tile_shading ===
|
|
|
9565
|
|
|
9566 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( TileShadingRenderPassFlagBitsQCOM value )
|
|
|
9567 {
|
|
|
9568 switch ( value )
|
|
|
9569 {
|
|
|
9570 case TileShadingRenderPassFlagBitsQCOM::eEnable : return "Enable";
|
|
|
9571 case TileShadingRenderPassFlagBitsQCOM::ePerTileExecution: return "PerTileExecution";
|
|
|
9572 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9573 }
|
|
|
9574 }
|
|
|
9575
|
|
|
9576 #if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
9577 //=== VK_EXT_metal_objects ===
|
|
|
9578
|
|
|
9579 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ExportMetalObjectTypeFlagBitsEXT value )
|
|
|
9580 {
|
|
|
9581 switch ( value )
|
|
|
9582 {
|
|
|
9583 case ExportMetalObjectTypeFlagBitsEXT::eMetalDevice : return "MetalDevice";
|
|
|
9584 case ExportMetalObjectTypeFlagBitsEXT::eMetalCommandQueue: return "MetalCommandQueue";
|
|
|
9585 case ExportMetalObjectTypeFlagBitsEXT::eMetalBuffer : return "MetalBuffer";
|
|
|
9586 case ExportMetalObjectTypeFlagBitsEXT::eMetalTexture : return "MetalTexture";
|
|
|
9587 case ExportMetalObjectTypeFlagBitsEXT::eMetalIosurface : return "MetalIosurface";
|
|
|
9588 case ExportMetalObjectTypeFlagBitsEXT::eMetalSharedEvent : return "MetalSharedEvent";
|
|
|
9589 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9590 }
|
|
|
9591 }
|
|
|
9592 #endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
9593
|
|
|
9594 //=== VK_EXT_graphics_pipeline_library ===
|
|
|
9595
|
|
|
9596 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( GraphicsPipelineLibraryFlagBitsEXT value )
|
|
|
9597 {
|
|
|
9598 switch ( value )
|
|
|
9599 {
|
|
|
9600 case GraphicsPipelineLibraryFlagBitsEXT::eVertexInputInterface : return "VertexInputInterface";
|
|
|
9601 case GraphicsPipelineLibraryFlagBitsEXT::ePreRasterizationShaders: return "PreRasterizationShaders";
|
|
|
9602 case GraphicsPipelineLibraryFlagBitsEXT::eFragmentShader : return "FragmentShader";
|
|
|
9603 case GraphicsPipelineLibraryFlagBitsEXT::eFragmentOutputInterface: return "FragmentOutputInterface";
|
|
|
9604 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9605 }
|
|
|
9606 }
|
|
|
9607
|
|
|
9608 //=== VK_NV_fragment_shading_rate_enums ===
|
|
|
9609
|
|
|
9610 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FragmentShadingRateNV value )
|
|
|
9611 {
|
|
|
9612 switch ( value )
|
|
|
9613 {
|
|
|
9614 case FragmentShadingRateNV::e1InvocationPerPixel : return "1InvocationPerPixel";
|
|
|
9615 case FragmentShadingRateNV::e1InvocationPer1X2Pixels: return "1InvocationPer1X2Pixels";
|
|
|
9616 case FragmentShadingRateNV::e1InvocationPer2X1Pixels: return "1InvocationPer2X1Pixels";
|
|
|
9617 case FragmentShadingRateNV::e1InvocationPer2X2Pixels: return "1InvocationPer2X2Pixels";
|
|
|
9618 case FragmentShadingRateNV::e1InvocationPer2X4Pixels: return "1InvocationPer2X4Pixels";
|
|
|
9619 case FragmentShadingRateNV::e1InvocationPer4X2Pixels: return "1InvocationPer4X2Pixels";
|
|
|
9620 case FragmentShadingRateNV::e1InvocationPer4X4Pixels: return "1InvocationPer4X4Pixels";
|
|
|
9621 case FragmentShadingRateNV::e2InvocationsPerPixel : return "2InvocationsPerPixel";
|
|
|
9622 case FragmentShadingRateNV::e4InvocationsPerPixel : return "4InvocationsPerPixel";
|
|
|
9623 case FragmentShadingRateNV::e8InvocationsPerPixel : return "8InvocationsPerPixel";
|
|
|
9624 case FragmentShadingRateNV::e16InvocationsPerPixel : return "16InvocationsPerPixel";
|
|
|
9625 case FragmentShadingRateNV::eNoInvocations : return "NoInvocations";
|
|
|
9626 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9627 }
|
|
|
9628 }
|
|
|
9629
|
|
|
9630 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FragmentShadingRateTypeNV value )
|
|
|
9631 {
|
|
|
9632 switch ( value )
|
|
|
9633 {
|
|
|
9634 case FragmentShadingRateTypeNV::eFragmentSize: return "FragmentSize";
|
|
|
9635 case FragmentShadingRateTypeNV::eEnums : return "Enums";
|
|
|
9636 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9637 }
|
|
|
9638 }
|
|
|
9639
|
|
|
9640 //=== VK_NV_ray_tracing_motion_blur ===
|
|
|
9641
|
|
|
9642 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureMotionInstanceTypeNV value )
|
|
|
9643 {
|
|
|
9644 switch ( value )
|
|
|
9645 {
|
|
|
9646 case AccelerationStructureMotionInstanceTypeNV::eStatic : return "Static";
|
|
|
9647 case AccelerationStructureMotionInstanceTypeNV::eMatrixMotion: return "MatrixMotion";
|
|
|
9648 case AccelerationStructureMotionInstanceTypeNV::eSrtMotion : return "SrtMotion";
|
|
|
9649 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9650 }
|
|
|
9651 }
|
|
|
9652
|
|
|
9653 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureMotionInfoFlagBitsNV )
|
|
|
9654 {
|
|
|
9655 return "(void)";
|
|
|
9656 }
|
|
|
9657
|
|
|
9658 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureMotionInstanceFlagBitsNV )
|
|
|
9659 {
|
|
|
9660 return "(void)";
|
|
|
9661 }
|
|
|
9662
|
|
|
9663 //=== VK_EXT_image_compression_control ===
|
|
|
9664
|
|
|
9665 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageCompressionFlagBitsEXT value )
|
|
|
9666 {
|
|
|
9667 switch ( value )
|
|
|
9668 {
|
|
|
9669 case ImageCompressionFlagBitsEXT::eDefault : return "Default";
|
|
|
9670 case ImageCompressionFlagBitsEXT::eFixedRateDefault : return "FixedRateDefault";
|
|
|
9671 case ImageCompressionFlagBitsEXT::eFixedRateExplicit: return "FixedRateExplicit";
|
|
|
9672 case ImageCompressionFlagBitsEXT::eDisabled : return "Disabled";
|
|
|
9673 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9674 }
|
|
|
9675 }
|
|
|
9676
|
|
|
9677 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageCompressionFixedRateFlagBitsEXT value )
|
|
|
9678 {
|
|
|
9679 switch ( value )
|
|
|
9680 {
|
|
|
9681 case ImageCompressionFixedRateFlagBitsEXT::eNone : return "None";
|
|
|
9682 case ImageCompressionFixedRateFlagBitsEXT::e1Bpc : return "1Bpc";
|
|
|
9683 case ImageCompressionFixedRateFlagBitsEXT::e2Bpc : return "2Bpc";
|
|
|
9684 case ImageCompressionFixedRateFlagBitsEXT::e3Bpc : return "3Bpc";
|
|
|
9685 case ImageCompressionFixedRateFlagBitsEXT::e4Bpc : return "4Bpc";
|
|
|
9686 case ImageCompressionFixedRateFlagBitsEXT::e5Bpc : return "5Bpc";
|
|
|
9687 case ImageCompressionFixedRateFlagBitsEXT::e6Bpc : return "6Bpc";
|
|
|
9688 case ImageCompressionFixedRateFlagBitsEXT::e7Bpc : return "7Bpc";
|
|
|
9689 case ImageCompressionFixedRateFlagBitsEXT::e8Bpc : return "8Bpc";
|
|
|
9690 case ImageCompressionFixedRateFlagBitsEXT::e9Bpc : return "9Bpc";
|
|
|
9691 case ImageCompressionFixedRateFlagBitsEXT::e10Bpc: return "10Bpc";
|
|
|
9692 case ImageCompressionFixedRateFlagBitsEXT::e11Bpc: return "11Bpc";
|
|
|
9693 case ImageCompressionFixedRateFlagBitsEXT::e12Bpc: return "12Bpc";
|
|
|
9694 case ImageCompressionFixedRateFlagBitsEXT::e13Bpc: return "13Bpc";
|
|
|
9695 case ImageCompressionFixedRateFlagBitsEXT::e14Bpc: return "14Bpc";
|
|
|
9696 case ImageCompressionFixedRateFlagBitsEXT::e15Bpc: return "15Bpc";
|
|
|
9697 case ImageCompressionFixedRateFlagBitsEXT::e16Bpc: return "16Bpc";
|
|
|
9698 case ImageCompressionFixedRateFlagBitsEXT::e17Bpc: return "17Bpc";
|
|
|
9699 case ImageCompressionFixedRateFlagBitsEXT::e18Bpc: return "18Bpc";
|
|
|
9700 case ImageCompressionFixedRateFlagBitsEXT::e19Bpc: return "19Bpc";
|
|
|
9701 case ImageCompressionFixedRateFlagBitsEXT::e20Bpc: return "20Bpc";
|
|
|
9702 case ImageCompressionFixedRateFlagBitsEXT::e21Bpc: return "21Bpc";
|
|
|
9703 case ImageCompressionFixedRateFlagBitsEXT::e22Bpc: return "22Bpc";
|
|
|
9704 case ImageCompressionFixedRateFlagBitsEXT::e23Bpc: return "23Bpc";
|
|
|
9705 case ImageCompressionFixedRateFlagBitsEXT::e24Bpc: return "24Bpc";
|
|
|
9706 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9707 }
|
|
|
9708 }
|
|
|
9709
|
|
|
9710 //=== VK_EXT_device_fault ===
|
|
|
9711
|
|
|
9712 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceFaultAddressTypeEXT value )
|
|
|
9713 {
|
|
|
9714 switch ( value )
|
|
|
9715 {
|
|
|
9716 case DeviceFaultAddressTypeEXT::eNone : return "None";
|
|
|
9717 case DeviceFaultAddressTypeEXT::eReadInvalid : return "ReadInvalid";
|
|
|
9718 case DeviceFaultAddressTypeEXT::eWriteInvalid : return "WriteInvalid";
|
|
|
9719 case DeviceFaultAddressTypeEXT::eExecuteInvalid : return "ExecuteInvalid";
|
|
|
9720 case DeviceFaultAddressTypeEXT::eInstructionPointerUnknown: return "InstructionPointerUnknown";
|
|
|
9721 case DeviceFaultAddressTypeEXT::eInstructionPointerInvalid: return "InstructionPointerInvalid";
|
|
|
9722 case DeviceFaultAddressTypeEXT::eInstructionPointerFault : return "InstructionPointerFault";
|
|
|
9723 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9724 }
|
|
|
9725 }
|
|
|
9726
|
|
|
9727 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceFaultVendorBinaryHeaderVersionEXT value )
|
|
|
9728 {
|
|
|
9729 switch ( value )
|
|
|
9730 {
|
|
|
9731 case DeviceFaultVendorBinaryHeaderVersionEXT::eOne: return "One";
|
|
|
9732 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9733 }
|
|
|
9734 }
|
|
|
9735
|
|
|
9736 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
|
|
|
9737 //=== VK_EXT_directfb_surface ===
|
|
|
9738
|
|
|
9739 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DirectFBSurfaceCreateFlagBitsEXT )
|
|
|
9740 {
|
|
|
9741 return "(void)";
|
|
|
9742 }
|
|
|
9743 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
|
|
|
9744
|
|
|
9745 //=== VK_EXT_device_address_binding_report ===
|
|
|
9746
|
|
|
9747 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceAddressBindingFlagBitsEXT value )
|
|
|
9748 {
|
|
|
9749 switch ( value )
|
|
|
9750 {
|
|
|
9751 case DeviceAddressBindingFlagBitsEXT::eInternalObject: return "InternalObject";
|
|
|
9752 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9753 }
|
|
|
9754 }
|
|
|
9755
|
|
|
9756 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceAddressBindingTypeEXT value )
|
|
|
9757 {
|
|
|
9758 switch ( value )
|
|
|
9759 {
|
|
|
9760 case DeviceAddressBindingTypeEXT::eBind : return "Bind";
|
|
|
9761 case DeviceAddressBindingTypeEXT::eUnbind: return "Unbind";
|
|
|
9762 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9763 }
|
|
|
9764 }
|
|
|
9765
|
|
|
9766 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
9767 //=== VK_FUCHSIA_buffer_collection ===
|
|
|
9768
|
|
|
9769 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageConstraintsInfoFlagBitsFUCHSIA value )
|
|
|
9770 {
|
|
|
9771 switch ( value )
|
|
|
9772 {
|
|
|
9773 case ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadRarely : return "CpuReadRarely";
|
|
|
9774 case ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadOften : return "CpuReadOften";
|
|
|
9775 case ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteRarely : return "CpuWriteRarely";
|
|
|
9776 case ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteOften : return "CpuWriteOften";
|
|
|
9777 case ImageConstraintsInfoFlagBitsFUCHSIA::eProtectedOptional: return "ProtectedOptional";
|
|
|
9778 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9779 }
|
|
|
9780 }
|
|
|
9781
|
|
|
9782 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageFormatConstraintsFlagBitsFUCHSIA )
|
|
|
9783 {
|
|
|
9784 return "(void)";
|
|
|
9785 }
|
|
|
9786 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
9787
|
|
|
9788 //=== VK_EXT_frame_boundary ===
|
|
|
9789
|
|
|
9790 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FrameBoundaryFlagBitsEXT value )
|
|
|
9791 {
|
|
|
9792 switch ( value )
|
|
|
9793 {
|
|
|
9794 case FrameBoundaryFlagBitsEXT::eFrameEnd: return "FrameEnd";
|
|
|
9795 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9796 }
|
|
|
9797 }
|
|
|
9798
|
|
|
9799 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
|
9800 //=== VK_QNX_screen_surface ===
|
|
|
9801
|
|
|
9802 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ScreenSurfaceCreateFlagBitsQNX )
|
|
|
9803 {
|
|
|
9804 return "(void)";
|
|
|
9805 }
|
|
|
9806 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
|
9807
|
|
|
9808 //=== VK_VALVE_video_encode_rgb_conversion ===
|
|
|
9809
|
|
|
9810 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeRgbModelConversionFlagBitsVALVE value )
|
|
|
9811 {
|
|
|
9812 switch ( value )
|
|
|
9813 {
|
|
|
9814 case VideoEncodeRgbModelConversionFlagBitsVALVE::eRgbIdentity : return "RgbIdentity";
|
|
|
9815 case VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcrIdentity: return "YcbcrIdentity";
|
|
|
9816 case VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr709 : return "Ycbcr709";
|
|
|
9817 case VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr601 : return "Ycbcr601";
|
|
|
9818 case VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr2020 : return "Ycbcr2020";
|
|
|
9819 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9820 }
|
|
|
9821 }
|
|
|
9822
|
|
|
9823 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeRgbRangeCompressionFlagBitsVALVE value )
|
|
|
9824 {
|
|
|
9825 switch ( value )
|
|
|
9826 {
|
|
|
9827 case VideoEncodeRgbRangeCompressionFlagBitsVALVE::eFullRange : return "FullRange";
|
|
|
9828 case VideoEncodeRgbRangeCompressionFlagBitsVALVE::eNarrowRange: return "NarrowRange";
|
|
|
9829 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9830 }
|
|
|
9831 }
|
|
|
9832
|
|
|
9833 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeRgbChromaOffsetFlagBitsVALVE value )
|
|
|
9834 {
|
|
|
9835 switch ( value )
|
|
|
9836 {
|
|
|
9837 case VideoEncodeRgbChromaOffsetFlagBitsVALVE::eCositedEven: return "CositedEven";
|
|
|
9838 case VideoEncodeRgbChromaOffsetFlagBitsVALVE::eMidpoint : return "Midpoint";
|
|
|
9839 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9840 }
|
|
|
9841 }
|
|
|
9842
|
|
|
9843 //=== VK_EXT_opacity_micromap ===
|
|
|
9844
|
|
|
9845 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MicromapTypeEXT value )
|
|
|
9846 {
|
|
|
9847 switch ( value )
|
|
|
9848 {
|
|
|
9849 case MicromapTypeEXT::eOpacityMicromap: return "OpacityMicromap";
|
|
|
9850 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
9851 case MicromapTypeEXT::eDisplacementMicromapNV: return "DisplacementMicromapNV";
|
|
|
9852 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
9853 default: return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9854 }
|
|
|
9855 }
|
|
|
9856
|
|
|
9857 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BuildMicromapFlagBitsEXT value )
|
|
|
9858 {
|
|
|
9859 switch ( value )
|
|
|
9860 {
|
|
|
9861 case BuildMicromapFlagBitsEXT::ePreferFastTrace: return "PreferFastTrace";
|
|
|
9862 case BuildMicromapFlagBitsEXT::ePreferFastBuild: return "PreferFastBuild";
|
|
|
9863 case BuildMicromapFlagBitsEXT::eAllowCompaction: return "AllowCompaction";
|
|
|
9864 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9865 }
|
|
|
9866 }
|
|
|
9867
|
|
|
9868 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CopyMicromapModeEXT value )
|
|
|
9869 {
|
|
|
9870 switch ( value )
|
|
|
9871 {
|
|
|
9872 case CopyMicromapModeEXT::eClone : return "Clone";
|
|
|
9873 case CopyMicromapModeEXT::eSerialize : return "Serialize";
|
|
|
9874 case CopyMicromapModeEXT::eDeserialize: return "Deserialize";
|
|
|
9875 case CopyMicromapModeEXT::eCompact : return "Compact";
|
|
|
9876 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9877 }
|
|
|
9878 }
|
|
|
9879
|
|
|
9880 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MicromapCreateFlagBitsEXT value )
|
|
|
9881 {
|
|
|
9882 switch ( value )
|
|
|
9883 {
|
|
|
9884 case MicromapCreateFlagBitsEXT::eDeviceAddressCaptureReplay: return "DeviceAddressCaptureReplay";
|
|
|
9885 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9886 }
|
|
|
9887 }
|
|
|
9888
|
|
|
9889 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BuildMicromapModeEXT value )
|
|
|
9890 {
|
|
|
9891 switch ( value )
|
|
|
9892 {
|
|
|
9893 case BuildMicromapModeEXT::eBuild: return "Build";
|
|
|
9894 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9895 }
|
|
|
9896 }
|
|
|
9897
|
|
|
9898 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OpacityMicromapFormatEXT value )
|
|
|
9899 {
|
|
|
9900 switch ( value )
|
|
|
9901 {
|
|
|
9902 case OpacityMicromapFormatEXT::e2State: return "2State";
|
|
|
9903 case OpacityMicromapFormatEXT::e4State: return "4State";
|
|
|
9904 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9905 }
|
|
|
9906 }
|
|
|
9907
|
|
|
9908 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OpacityMicromapSpecialIndexEXT value )
|
|
|
9909 {
|
|
|
9910 switch ( value )
|
|
|
9911 {
|
|
|
9912 case OpacityMicromapSpecialIndexEXT::eFullyTransparent : return "FullyTransparent";
|
|
|
9913 case OpacityMicromapSpecialIndexEXT::eFullyOpaque : return "FullyOpaque";
|
|
|
9914 case OpacityMicromapSpecialIndexEXT::eFullyUnknownTransparent : return "FullyUnknownTransparent";
|
|
|
9915 case OpacityMicromapSpecialIndexEXT::eFullyUnknownOpaque : return "FullyUnknownOpaque";
|
|
|
9916 case OpacityMicromapSpecialIndexEXT::eClusterGeometryDisableOpacityMicromapNV: return "ClusterGeometryDisableOpacityMicromapNV";
|
|
|
9917 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9918 }
|
|
|
9919 }
|
|
|
9920
|
|
|
9921 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
9922 //=== VK_NV_displacement_micromap ===
|
|
|
9923
|
|
|
9924 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DisplacementMicromapFormatNV value )
|
|
|
9925 {
|
|
|
9926 switch ( value )
|
|
|
9927 {
|
|
|
9928 case DisplacementMicromapFormatNV::e64Triangles64Bytes : return "64Triangles64Bytes";
|
|
|
9929 case DisplacementMicromapFormatNV::e256Triangles128Bytes : return "256Triangles128Bytes";
|
|
|
9930 case DisplacementMicromapFormatNV::e1024Triangles128Bytes: return "1024Triangles128Bytes";
|
|
|
9931 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9932 }
|
|
|
9933 }
|
|
|
9934 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
9935
|
|
|
9936 //=== VK_ARM_scheduling_controls ===
|
|
|
9937
|
|
|
9938 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PhysicalDeviceSchedulingControlsFlagBitsARM value )
|
|
|
9939 {
|
|
|
9940 switch ( value )
|
|
|
9941 {
|
|
|
9942 case PhysicalDeviceSchedulingControlsFlagBitsARM::eShaderCoreCount: return "ShaderCoreCount";
|
|
|
9943 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9944 }
|
|
|
9945 }
|
|
|
9946
|
|
|
9947 //=== VK_NV_ray_tracing_linear_swept_spheres ===
|
|
|
9948
|
|
|
9949 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( RayTracingLssIndexingModeNV value )
|
|
|
9950 {
|
|
|
9951 switch ( value )
|
|
|
9952 {
|
|
|
9953 case RayTracingLssIndexingModeNV::eList : return "List";
|
|
|
9954 case RayTracingLssIndexingModeNV::eSuccessive: return "Successive";
|
|
|
9955 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9956 }
|
|
|
9957 }
|
|
|
9958
|
|
|
9959 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( RayTracingLssPrimitiveEndCapsModeNV value )
|
|
|
9960 {
|
|
|
9961 switch ( value )
|
|
|
9962 {
|
|
|
9963 case RayTracingLssPrimitiveEndCapsModeNV::eNone : return "None";
|
|
|
9964 case RayTracingLssPrimitiveEndCapsModeNV::eChained: return "Chained";
|
|
|
9965 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9966 }
|
|
|
9967 }
|
|
|
9968
|
|
|
9969 //=== VK_EXT_subpass_merge_feedback ===
|
|
|
9970
|
|
|
9971 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SubpassMergeStatusEXT value )
|
|
|
9972 {
|
|
|
9973 switch ( value )
|
|
|
9974 {
|
|
|
9975 case SubpassMergeStatusEXT::eMerged : return "Merged";
|
|
|
9976 case SubpassMergeStatusEXT::eDisallowed : return "Disallowed";
|
|
|
9977 case SubpassMergeStatusEXT::eNotMergedSideEffects : return "NotMergedSideEffects";
|
|
|
9978 case SubpassMergeStatusEXT::eNotMergedSamplesMismatch : return "NotMergedSamplesMismatch";
|
|
|
9979 case SubpassMergeStatusEXT::eNotMergedViewsMismatch : return "NotMergedViewsMismatch";
|
|
|
9980 case SubpassMergeStatusEXT::eNotMergedAliasing : return "NotMergedAliasing";
|
|
|
9981 case SubpassMergeStatusEXT::eNotMergedDependencies : return "NotMergedDependencies";
|
|
|
9982 case SubpassMergeStatusEXT::eNotMergedIncompatibleInputAttachment: return "NotMergedIncompatibleInputAttachment";
|
|
|
9983 case SubpassMergeStatusEXT::eNotMergedTooManyAttachments : return "NotMergedTooManyAttachments";
|
|
|
9984 case SubpassMergeStatusEXT::eNotMergedInsufficientStorage : return "NotMergedInsufficientStorage";
|
|
|
9985 case SubpassMergeStatusEXT::eNotMergedDepthStencilCount : return "NotMergedDepthStencilCount";
|
|
|
9986 case SubpassMergeStatusEXT::eNotMergedResolveAttachmentReuse : return "NotMergedResolveAttachmentReuse";
|
|
|
9987 case SubpassMergeStatusEXT::eNotMergedSingleSubpass : return "NotMergedSingleSubpass";
|
|
|
9988 case SubpassMergeStatusEXT::eNotMergedUnspecified : return "NotMergedUnspecified";
|
|
|
9989 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
9990 }
|
|
|
9991 }
|
|
|
9992
|
|
|
9993 //=== VK_LUNARG_direct_driver_loading ===
|
|
|
9994
|
|
|
9995 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DirectDriverLoadingModeLUNARG value )
|
|
|
9996 {
|
|
|
9997 switch ( value )
|
|
|
9998 {
|
|
|
9999 case DirectDriverLoadingModeLUNARG::eExclusive: return "Exclusive";
|
|
|
10000 case DirectDriverLoadingModeLUNARG::eInclusive: return "Inclusive";
|
|
|
10001 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10002 }
|
|
|
10003 }
|
|
|
10004
|
|
|
10005 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DirectDriverLoadingFlagBitsLUNARG )
|
|
|
10006 {
|
|
|
10007 return "(void)";
|
|
|
10008 }
|
|
|
10009
|
|
|
10010 //=== VK_ARM_tensors ===
|
|
|
10011
|
|
|
10012 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( TensorCreateFlagBitsARM value )
|
|
|
10013 {
|
|
|
10014 switch ( value )
|
|
|
10015 {
|
|
|
10016 case TensorCreateFlagBitsARM::eMutableFormat : return "MutableFormat";
|
|
|
10017 case TensorCreateFlagBitsARM::eProtected : return "Protected";
|
|
|
10018 case TensorCreateFlagBitsARM::eDescriptorBufferCaptureReplay: return "DescriptorBufferCaptureReplay";
|
|
|
10019 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10020 }
|
|
|
10021 }
|
|
|
10022
|
|
|
10023 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( TensorViewCreateFlagBitsARM value )
|
|
|
10024 {
|
|
|
10025 switch ( value )
|
|
|
10026 {
|
|
|
10027 case TensorViewCreateFlagBitsARM::eDescriptorBufferCaptureReplay: return "DescriptorBufferCaptureReplay";
|
|
|
10028 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10029 }
|
|
|
10030 }
|
|
|
10031
|
|
|
10032 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( TensorUsageFlagBitsARM value )
|
|
|
10033 {
|
|
|
10034 switch ( value )
|
|
|
10035 {
|
|
|
10036 case TensorUsageFlagBitsARM::eShader : return "Shader";
|
|
|
10037 case TensorUsageFlagBitsARM::eTransferSrc : return "TransferSrc";
|
|
|
10038 case TensorUsageFlagBitsARM::eTransferDst : return "TransferDst";
|
|
|
10039 case TensorUsageFlagBitsARM::eImageAliasing: return "ImageAliasing";
|
|
|
10040 case TensorUsageFlagBitsARM::eDataGraph : return "DataGraph";
|
|
|
10041 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10042 }
|
|
|
10043 }
|
|
|
10044
|
|
|
10045 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( TensorTilingARM value )
|
|
|
10046 {
|
|
|
10047 switch ( value )
|
|
|
10048 {
|
|
|
10049 case TensorTilingARM::eOptimal: return "Optimal";
|
|
|
10050 case TensorTilingARM::eLinear : return "Linear";
|
|
|
10051 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10052 }
|
|
|
10053 }
|
|
|
10054
|
|
|
10055 //=== VK_NV_optical_flow ===
|
|
|
10056
|
|
|
10057 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OpticalFlowUsageFlagBitsNV value )
|
|
|
10058 {
|
|
|
10059 switch ( value )
|
|
|
10060 {
|
|
|
10061 case OpticalFlowUsageFlagBitsNV::eUnknown : return "Unknown";
|
|
|
10062 case OpticalFlowUsageFlagBitsNV::eInput : return "Input";
|
|
|
10063 case OpticalFlowUsageFlagBitsNV::eOutput : return "Output";
|
|
|
10064 case OpticalFlowUsageFlagBitsNV::eHint : return "Hint";
|
|
|
10065 case OpticalFlowUsageFlagBitsNV::eCost : return "Cost";
|
|
|
10066 case OpticalFlowUsageFlagBitsNV::eGlobalFlow: return "GlobalFlow";
|
|
|
10067 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10068 }
|
|
|
10069 }
|
|
|
10070
|
|
|
10071 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OpticalFlowGridSizeFlagBitsNV value )
|
|
|
10072 {
|
|
|
10073 switch ( value )
|
|
|
10074 {
|
|
|
10075 case OpticalFlowGridSizeFlagBitsNV::eUnknown: return "Unknown";
|
|
|
10076 case OpticalFlowGridSizeFlagBitsNV::e1X1 : return "1X1";
|
|
|
10077 case OpticalFlowGridSizeFlagBitsNV::e2X2 : return "2X2";
|
|
|
10078 case OpticalFlowGridSizeFlagBitsNV::e4X4 : return "4X4";
|
|
|
10079 case OpticalFlowGridSizeFlagBitsNV::e8X8 : return "8X8";
|
|
|
10080 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10081 }
|
|
|
10082 }
|
|
|
10083
|
|
|
10084 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OpticalFlowPerformanceLevelNV value )
|
|
|
10085 {
|
|
|
10086 switch ( value )
|
|
|
10087 {
|
|
|
10088 case OpticalFlowPerformanceLevelNV::eUnknown: return "Unknown";
|
|
|
10089 case OpticalFlowPerformanceLevelNV::eSlow : return "Slow";
|
|
|
10090 case OpticalFlowPerformanceLevelNV::eMedium : return "Medium";
|
|
|
10091 case OpticalFlowPerformanceLevelNV::eFast : return "Fast";
|
|
|
10092 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10093 }
|
|
|
10094 }
|
|
|
10095
|
|
|
10096 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OpticalFlowSessionBindingPointNV value )
|
|
|
10097 {
|
|
|
10098 switch ( value )
|
|
|
10099 {
|
|
|
10100 case OpticalFlowSessionBindingPointNV::eUnknown : return "Unknown";
|
|
|
10101 case OpticalFlowSessionBindingPointNV::eInput : return "Input";
|
|
|
10102 case OpticalFlowSessionBindingPointNV::eReference : return "Reference";
|
|
|
10103 case OpticalFlowSessionBindingPointNV::eHint : return "Hint";
|
|
|
10104 case OpticalFlowSessionBindingPointNV::eFlowVector : return "FlowVector";
|
|
|
10105 case OpticalFlowSessionBindingPointNV::eBackwardFlowVector: return "BackwardFlowVector";
|
|
|
10106 case OpticalFlowSessionBindingPointNV::eCost : return "Cost";
|
|
|
10107 case OpticalFlowSessionBindingPointNV::eBackwardCost : return "BackwardCost";
|
|
|
10108 case OpticalFlowSessionBindingPointNV::eGlobalFlow : return "GlobalFlow";
|
|
|
10109 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10110 }
|
|
|
10111 }
|
|
|
10112
|
|
|
10113 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OpticalFlowSessionCreateFlagBitsNV value )
|
|
|
10114 {
|
|
|
10115 switch ( value )
|
|
|
10116 {
|
|
|
10117 case OpticalFlowSessionCreateFlagBitsNV::eEnableHint : return "EnableHint";
|
|
|
10118 case OpticalFlowSessionCreateFlagBitsNV::eEnableCost : return "EnableCost";
|
|
|
10119 case OpticalFlowSessionCreateFlagBitsNV::eEnableGlobalFlow: return "EnableGlobalFlow";
|
|
|
10120 case OpticalFlowSessionCreateFlagBitsNV::eAllowRegions : return "AllowRegions";
|
|
|
10121 case OpticalFlowSessionCreateFlagBitsNV::eBothDirections : return "BothDirections";
|
|
|
10122 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10123 }
|
|
|
10124 }
|
|
|
10125
|
|
|
10126 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OpticalFlowExecuteFlagBitsNV value )
|
|
|
10127 {
|
|
|
10128 switch ( value )
|
|
|
10129 {
|
|
|
10130 case OpticalFlowExecuteFlagBitsNV::eDisableTemporalHints: return "DisableTemporalHints";
|
|
|
10131 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10132 }
|
|
|
10133 }
|
|
|
10134
|
|
|
10135 //=== VK_AMD_anti_lag ===
|
|
|
10136
|
|
|
10137 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AntiLagModeAMD value )
|
|
|
10138 {
|
|
|
10139 switch ( value )
|
|
|
10140 {
|
|
|
10141 case AntiLagModeAMD::eDriverControl: return "DriverControl";
|
|
|
10142 case AntiLagModeAMD::eOn : return "On";
|
|
|
10143 case AntiLagModeAMD::eOff : return "Off";
|
|
|
10144 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10145 }
|
|
|
10146 }
|
|
|
10147
|
|
|
10148 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AntiLagStageAMD value )
|
|
|
10149 {
|
|
|
10150 switch ( value )
|
|
|
10151 {
|
|
|
10152 case AntiLagStageAMD::eInput : return "Input";
|
|
|
10153 case AntiLagStageAMD::ePresent: return "Present";
|
|
|
10154 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10155 }
|
|
|
10156 }
|
|
|
10157
|
|
|
10158 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
10159 //=== VK_AMDX_dense_geometry_format ===
|
|
|
10160
|
|
|
10161 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CompressedTriangleFormatAMDX value )
|
|
|
10162 {
|
|
|
10163 switch ( value )
|
|
|
10164 {
|
|
|
10165 case CompressedTriangleFormatAMDX::eDgf1: return "Dgf1";
|
|
|
10166 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10167 }
|
|
|
10168 }
|
|
|
10169 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
10170
|
|
|
10171 //=== VK_EXT_shader_object ===
|
|
|
10172
|
|
|
10173 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderCreateFlagBitsEXT value )
|
|
|
10174 {
|
|
|
10175 switch ( value )
|
|
|
10176 {
|
|
|
10177 case ShaderCreateFlagBitsEXT::eLinkStage : return "LinkStage";
|
|
|
10178 case ShaderCreateFlagBitsEXT::eAllowVaryingSubgroupSize : return "AllowVaryingSubgroupSize";
|
|
|
10179 case ShaderCreateFlagBitsEXT::eRequireFullSubgroups : return "RequireFullSubgroups";
|
|
|
10180 case ShaderCreateFlagBitsEXT::eNoTaskShader : return "NoTaskShader";
|
|
|
10181 case ShaderCreateFlagBitsEXT::eDispatchBase : return "DispatchBase";
|
|
|
10182 case ShaderCreateFlagBitsEXT::eFragmentShadingRateAttachment: return "FragmentShadingRateAttachment";
|
|
|
10183 case ShaderCreateFlagBitsEXT::eFragmentDensityMapAttachment : return "FragmentDensityMapAttachment";
|
|
|
10184 case ShaderCreateFlagBitsEXT::eIndirectBindable : return "IndirectBindable";
|
|
|
10185 case ShaderCreateFlagBitsEXT::e64BitIndexing : return "64BitIndexing";
|
|
|
10186 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10187 }
|
|
|
10188 }
|
|
|
10189
|
|
|
10190 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderCodeTypeEXT value )
|
|
|
10191 {
|
|
|
10192 switch ( value )
|
|
|
10193 {
|
|
|
10194 case ShaderCodeTypeEXT::eBinary: return "Binary";
|
|
|
10195 case ShaderCodeTypeEXT::eSpirv : return "Spirv";
|
|
|
10196 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10197 }
|
|
|
10198 }
|
|
|
10199
|
|
|
10200 //=== VK_KHR_surface_maintenance1 ===
|
|
|
10201
|
|
|
10202 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PresentScalingFlagBitsKHR value )
|
|
|
10203 {
|
|
|
10204 switch ( value )
|
|
|
10205 {
|
|
|
10206 case PresentScalingFlagBitsKHR::eOneToOne : return "OneToOne";
|
|
|
10207 case PresentScalingFlagBitsKHR::eAspectRatioStretch: return "AspectRatioStretch";
|
|
|
10208 case PresentScalingFlagBitsKHR::eStretch : return "Stretch";
|
|
|
10209 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10210 }
|
|
|
10211 }
|
|
|
10212
|
|
|
10213 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PresentGravityFlagBitsKHR value )
|
|
|
10214 {
|
|
|
10215 switch ( value )
|
|
|
10216 {
|
|
|
10217 case PresentGravityFlagBitsKHR::eMin : return "Min";
|
|
|
10218 case PresentGravityFlagBitsKHR::eMax : return "Max";
|
|
|
10219 case PresentGravityFlagBitsKHR::eCentered: return "Centered";
|
|
|
10220 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10221 }
|
|
|
10222 }
|
|
|
10223
|
|
|
10224 //=== VK_NV_cooperative_vector ===
|
|
|
10225
|
|
|
10226 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CooperativeVectorMatrixLayoutNV value )
|
|
|
10227 {
|
|
|
10228 switch ( value )
|
|
|
10229 {
|
|
|
10230 case CooperativeVectorMatrixLayoutNV::eRowMajor : return "RowMajor";
|
|
|
10231 case CooperativeVectorMatrixLayoutNV::eColumnMajor : return "ColumnMajor";
|
|
|
10232 case CooperativeVectorMatrixLayoutNV::eInferencingOptimal: return "InferencingOptimal";
|
|
|
10233 case CooperativeVectorMatrixLayoutNV::eTrainingOptimal : return "TrainingOptimal";
|
|
|
10234 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10235 }
|
|
|
10236 }
|
|
|
10237
|
|
|
10238 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ComponentTypeKHR value )
|
|
|
10239 {
|
|
|
10240 switch ( value )
|
|
|
10241 {
|
|
|
10242 case ComponentTypeKHR::eFloat16 : return "Float16";
|
|
|
10243 case ComponentTypeKHR::eFloat32 : return "Float32";
|
|
|
10244 case ComponentTypeKHR::eFloat64 : return "Float64";
|
|
|
10245 case ComponentTypeKHR::eSint8 : return "Sint8";
|
|
|
10246 case ComponentTypeKHR::eSint16 : return "Sint16";
|
|
|
10247 case ComponentTypeKHR::eSint32 : return "Sint32";
|
|
|
10248 case ComponentTypeKHR::eSint64 : return "Sint64";
|
|
|
10249 case ComponentTypeKHR::eUint8 : return "Uint8";
|
|
|
10250 case ComponentTypeKHR::eUint16 : return "Uint16";
|
|
|
10251 case ComponentTypeKHR::eUint32 : return "Uint32";
|
|
|
10252 case ComponentTypeKHR::eUint64 : return "Uint64";
|
|
|
10253 case ComponentTypeKHR::eBfloat16 : return "Bfloat16";
|
|
|
10254 case ComponentTypeKHR::eSint8PackedNV: return "Sint8PackedNV";
|
|
|
10255 case ComponentTypeKHR::eUint8PackedNV: return "Uint8PackedNV";
|
|
|
10256 case ComponentTypeKHR::eFloat8E4M3EXT: return "Float8E4M3EXT";
|
|
|
10257 case ComponentTypeKHR::eFloat8E5M2EXT: return "Float8E5M2EXT";
|
|
|
10258 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10259 }
|
|
|
10260 }
|
|
|
10261
|
|
|
10262 //=== VK_EXT_layer_settings ===
|
|
|
10263
|
|
|
10264 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( LayerSettingTypeEXT value )
|
|
|
10265 {
|
|
|
10266 switch ( value )
|
|
|
10267 {
|
|
|
10268 case LayerSettingTypeEXT::eBool32 : return "Bool32";
|
|
|
10269 case LayerSettingTypeEXT::eInt32 : return "Int32";
|
|
|
10270 case LayerSettingTypeEXT::eInt64 : return "Int64";
|
|
|
10271 case LayerSettingTypeEXT::eUint32 : return "Uint32";
|
|
|
10272 case LayerSettingTypeEXT::eUint64 : return "Uint64";
|
|
|
10273 case LayerSettingTypeEXT::eFloat32: return "Float32";
|
|
|
10274 case LayerSettingTypeEXT::eFloat64: return "Float64";
|
|
|
10275 case LayerSettingTypeEXT::eString : return "String";
|
|
|
10276 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10277 }
|
|
|
10278 }
|
|
|
10279
|
|
|
10280 //=== VK_NV_low_latency2 ===
|
|
|
10281
|
|
|
10282 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( LatencyMarkerNV value )
|
|
|
10283 {
|
|
|
10284 switch ( value )
|
|
|
10285 {
|
|
|
10286 case LatencyMarkerNV::eSimulationStart : return "SimulationStart";
|
|
|
10287 case LatencyMarkerNV::eSimulationEnd : return "SimulationEnd";
|
|
|
10288 case LatencyMarkerNV::eRendersubmitStart : return "RendersubmitStart";
|
|
|
10289 case LatencyMarkerNV::eRendersubmitEnd : return "RendersubmitEnd";
|
|
|
10290 case LatencyMarkerNV::ePresentStart : return "PresentStart";
|
|
|
10291 case LatencyMarkerNV::ePresentEnd : return "PresentEnd";
|
|
|
10292 case LatencyMarkerNV::eInputSample : return "InputSample";
|
|
|
10293 case LatencyMarkerNV::eTriggerFlash : return "TriggerFlash";
|
|
|
10294 case LatencyMarkerNV::eOutOfBandRendersubmitStart: return "OutOfBandRendersubmitStart";
|
|
|
10295 case LatencyMarkerNV::eOutOfBandRendersubmitEnd : return "OutOfBandRendersubmitEnd";
|
|
|
10296 case LatencyMarkerNV::eOutOfBandPresentStart : return "OutOfBandPresentStart";
|
|
|
10297 case LatencyMarkerNV::eOutOfBandPresentEnd : return "OutOfBandPresentEnd";
|
|
|
10298 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10299 }
|
|
|
10300 }
|
|
|
10301
|
|
|
10302 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OutOfBandQueueTypeNV value )
|
|
|
10303 {
|
|
|
10304 switch ( value )
|
|
|
10305 {
|
|
|
10306 case OutOfBandQueueTypeNV::eRender : return "Render";
|
|
|
10307 case OutOfBandQueueTypeNV::ePresent: return "Present";
|
|
|
10308 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10309 }
|
|
|
10310 }
|
|
|
10311
|
|
|
10312 //=== VK_KHR_cooperative_matrix ===
|
|
|
10313
|
|
|
10314 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ScopeKHR value )
|
|
|
10315 {
|
|
|
10316 switch ( value )
|
|
|
10317 {
|
|
|
10318 case ScopeKHR::eDevice : return "Device";
|
|
|
10319 case ScopeKHR::eWorkgroup : return "Workgroup";
|
|
|
10320 case ScopeKHR::eSubgroup : return "Subgroup";
|
|
|
10321 case ScopeKHR::eQueueFamily: return "QueueFamily";
|
|
|
10322 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10323 }
|
|
|
10324 }
|
|
|
10325
|
|
|
10326 //=== VK_ARM_data_graph ===
|
|
|
10327
|
|
|
10328 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphPipelineSessionBindPointARM value )
|
|
|
10329 {
|
|
|
10330 switch ( value )
|
|
|
10331 {
|
|
|
10332 case DataGraphPipelineSessionBindPointARM::eTransient: return "Transient";
|
|
|
10333 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10334 }
|
|
|
10335 }
|
|
|
10336
|
|
|
10337 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphPipelineSessionBindPointTypeARM value )
|
|
|
10338 {
|
|
|
10339 switch ( value )
|
|
|
10340 {
|
|
|
10341 case DataGraphPipelineSessionBindPointTypeARM::eMemory: return "Memory";
|
|
|
10342 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10343 }
|
|
|
10344 }
|
|
|
10345
|
|
|
10346 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphPipelineSessionCreateFlagBitsARM value )
|
|
|
10347 {
|
|
|
10348 switch ( value )
|
|
|
10349 {
|
|
|
10350 case DataGraphPipelineSessionCreateFlagBitsARM::eProtected: return "Protected";
|
|
|
10351 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10352 }
|
|
|
10353 }
|
|
|
10354
|
|
|
10355 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphPipelinePropertyARM value )
|
|
|
10356 {
|
|
|
10357 switch ( value )
|
|
|
10358 {
|
|
|
10359 case DataGraphPipelinePropertyARM::eCreationLog: return "CreationLog";
|
|
|
10360 case DataGraphPipelinePropertyARM::eIdentifier : return "Identifier";
|
|
|
10361 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10362 }
|
|
|
10363 }
|
|
|
10364
|
|
|
10365 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphPipelineDispatchFlagBitsARM )
|
|
|
10366 {
|
|
|
10367 return "(void)";
|
|
|
10368 }
|
|
|
10369
|
|
|
10370 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PhysicalDeviceDataGraphProcessingEngineTypeARM value )
|
|
|
10371 {
|
|
|
10372 switch ( value )
|
|
|
10373 {
|
|
|
10374 case PhysicalDeviceDataGraphProcessingEngineTypeARM::eDefault : return "Default";
|
|
|
10375 case PhysicalDeviceDataGraphProcessingEngineTypeARM::eNeuralQCOM : return "NeuralQCOM";
|
|
|
10376 case PhysicalDeviceDataGraphProcessingEngineTypeARM::eComputeQCOM: return "ComputeQCOM";
|
|
|
10377 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10378 }
|
|
|
10379 }
|
|
|
10380
|
|
|
10381 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PhysicalDeviceDataGraphOperationTypeARM value )
|
|
|
10382 {
|
|
|
10383 switch ( value )
|
|
|
10384 {
|
|
|
10385 case PhysicalDeviceDataGraphOperationTypeARM::eSpirvExtendedInstructionSet: return "SpirvExtendedInstructionSet";
|
|
|
10386 case PhysicalDeviceDataGraphOperationTypeARM::eNeuralModelQCOM : return "NeuralModelQCOM";
|
|
|
10387 case PhysicalDeviceDataGraphOperationTypeARM::eBuiltinModelQCOM : return "BuiltinModelQCOM";
|
|
|
10388 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10389 }
|
|
|
10390 }
|
|
|
10391
|
|
|
10392 //=== VK_KHR_video_encode_av1 ===
|
|
|
10393
|
|
|
10394 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeAV1PredictionModeKHR value )
|
|
|
10395 {
|
|
|
10396 switch ( value )
|
|
|
10397 {
|
|
|
10398 case VideoEncodeAV1PredictionModeKHR::eIntraOnly : return "IntraOnly";
|
|
|
10399 case VideoEncodeAV1PredictionModeKHR::eSingleReference : return "SingleReference";
|
|
|
10400 case VideoEncodeAV1PredictionModeKHR::eUnidirectionalCompound: return "UnidirectionalCompound";
|
|
|
10401 case VideoEncodeAV1PredictionModeKHR::eBidirectionalCompound : return "BidirectionalCompound";
|
|
|
10402 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10403 }
|
|
|
10404 }
|
|
|
10405
|
|
|
10406 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeAV1RateControlGroupKHR value )
|
|
|
10407 {
|
|
|
10408 switch ( value )
|
|
|
10409 {
|
|
|
10410 case VideoEncodeAV1RateControlGroupKHR::eIntra : return "Intra";
|
|
|
10411 case VideoEncodeAV1RateControlGroupKHR::ePredictive : return "Predictive";
|
|
|
10412 case VideoEncodeAV1RateControlGroupKHR::eBipredictive: return "Bipredictive";
|
|
|
10413 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10414 }
|
|
|
10415 }
|
|
|
10416
|
|
|
10417 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeAV1CapabilityFlagBitsKHR value )
|
|
|
10418 {
|
|
|
10419 switch ( value )
|
|
|
10420 {
|
|
|
10421 case VideoEncodeAV1CapabilityFlagBitsKHR::ePerRateControlGroupMinMaxQIndex: return "PerRateControlGroupMinMaxQIndex";
|
|
|
10422 case VideoEncodeAV1CapabilityFlagBitsKHR::eGenerateObuExtensionHeader : return "GenerateObuExtensionHeader";
|
|
|
10423 case VideoEncodeAV1CapabilityFlagBitsKHR::ePrimaryReferenceCdfOnly : return "PrimaryReferenceCdfOnly";
|
|
|
10424 case VideoEncodeAV1CapabilityFlagBitsKHR::eFrameSizeOverride : return "FrameSizeOverride";
|
|
|
10425 case VideoEncodeAV1CapabilityFlagBitsKHR::eMotionVectorScaling : return "MotionVectorScaling";
|
|
|
10426 case VideoEncodeAV1CapabilityFlagBitsKHR::eCompoundPredictionIntraRefresh : return "CompoundPredictionIntraRefresh";
|
|
|
10427 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10428 }
|
|
|
10429 }
|
|
|
10430
|
|
|
10431 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeAV1StdFlagBitsKHR value )
|
|
|
10432 {
|
|
|
10433 switch ( value )
|
|
|
10434 {
|
|
|
10435 case VideoEncodeAV1StdFlagBitsKHR::eUniformTileSpacingFlagSet: return "UniformTileSpacingFlagSet";
|
|
|
10436 case VideoEncodeAV1StdFlagBitsKHR::eSkipModePresentUnset : return "SkipModePresentUnset";
|
|
|
10437 case VideoEncodeAV1StdFlagBitsKHR::ePrimaryRefFrame : return "PrimaryRefFrame";
|
|
|
10438 case VideoEncodeAV1StdFlagBitsKHR::eDeltaQ : return "DeltaQ";
|
|
|
10439 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10440 }
|
|
|
10441 }
|
|
|
10442
|
|
|
10443 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeAV1SuperblockSizeFlagBitsKHR value )
|
|
|
10444 {
|
|
|
10445 switch ( value )
|
|
|
10446 {
|
|
|
10447 case VideoEncodeAV1SuperblockSizeFlagBitsKHR::e64 : return "64";
|
|
|
10448 case VideoEncodeAV1SuperblockSizeFlagBitsKHR::e128: return "128";
|
|
|
10449 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10450 }
|
|
|
10451 }
|
|
|
10452
|
|
|
10453 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeAV1RateControlFlagBitsKHR value )
|
|
|
10454 {
|
|
|
10455 switch ( value )
|
|
|
10456 {
|
|
|
10457 case VideoEncodeAV1RateControlFlagBitsKHR::eRegularGop : return "RegularGop";
|
|
|
10458 case VideoEncodeAV1RateControlFlagBitsKHR::eTemporalLayerPatternDyadic: return "TemporalLayerPatternDyadic";
|
|
|
10459 case VideoEncodeAV1RateControlFlagBitsKHR::eReferencePatternFlat : return "ReferencePatternFlat";
|
|
|
10460 case VideoEncodeAV1RateControlFlagBitsKHR::eReferencePatternDyadic : return "ReferencePatternDyadic";
|
|
|
10461 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10462 }
|
|
|
10463 }
|
|
|
10464
|
|
|
10465 //=== VK_QCOM_image_processing2 ===
|
|
|
10466
|
|
|
10467 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BlockMatchWindowCompareModeQCOM value )
|
|
|
10468 {
|
|
|
10469 switch ( value )
|
|
|
10470 {
|
|
|
10471 case BlockMatchWindowCompareModeQCOM::eMin: return "Min";
|
|
|
10472 case BlockMatchWindowCompareModeQCOM::eMax: return "Max";
|
|
|
10473 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10474 }
|
|
|
10475 }
|
|
|
10476
|
|
|
10477 //=== VK_QCOM_filter_cubic_weights ===
|
|
|
10478
|
|
|
10479 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CubicFilterWeightsQCOM value )
|
|
|
10480 {
|
|
|
10481 switch ( value )
|
|
|
10482 {
|
|
|
10483 case CubicFilterWeightsQCOM::eCatmullRom : return "CatmullRom";
|
|
|
10484 case CubicFilterWeightsQCOM::eZeroTangentCardinal: return "ZeroTangentCardinal";
|
|
|
10485 case CubicFilterWeightsQCOM::eBSpline : return "BSpline";
|
|
|
10486 case CubicFilterWeightsQCOM::eMitchellNetravali : return "MitchellNetravali";
|
|
|
10487 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10488 }
|
|
|
10489 }
|
|
|
10490
|
|
|
10491 //=== VK_MSFT_layered_driver ===
|
|
|
10492
|
|
|
10493 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( LayeredDriverUnderlyingApiMSFT value )
|
|
|
10494 {
|
|
|
10495 switch ( value )
|
|
|
10496 {
|
|
|
10497 case LayeredDriverUnderlyingApiMSFT::eNone : return "None";
|
|
|
10498 case LayeredDriverUnderlyingApiMSFT::eD3D12: return "D3D12";
|
|
|
10499 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10500 }
|
|
|
10501 }
|
|
|
10502
|
|
|
10503 //=== VK_KHR_calibrated_timestamps ===
|
|
|
10504
|
|
|
10505 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( TimeDomainKHR value )
|
|
|
10506 {
|
|
|
10507 switch ( value )
|
|
|
10508 {
|
|
|
10509 case TimeDomainKHR::eDevice : return "Device";
|
|
|
10510 case TimeDomainKHR::eClockMonotonic : return "ClockMonotonic";
|
|
|
10511 case TimeDomainKHR::eClockMonotonicRaw : return "ClockMonotonicRaw";
|
|
|
10512 case TimeDomainKHR::eQueryPerformanceCounter: return "QueryPerformanceCounter";
|
|
|
10513 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10514 }
|
|
|
10515 }
|
|
|
10516
|
|
|
10517 //=== VK_KHR_copy_memory_indirect ===
|
|
|
10518
|
|
|
10519 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AddressCopyFlagBitsKHR value )
|
|
|
10520 {
|
|
|
10521 switch ( value )
|
|
|
10522 {
|
|
|
10523 case AddressCopyFlagBitsKHR::eDeviceLocal: return "DeviceLocal";
|
|
|
10524 case AddressCopyFlagBitsKHR::eSparse : return "Sparse";
|
|
|
10525 case AddressCopyFlagBitsKHR::eProtected : return "Protected";
|
|
|
10526 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10527 }
|
|
|
10528 }
|
|
|
10529
|
|
|
10530 //=== VK_EXT_memory_decompression ===
|
|
|
10531
|
|
|
10532 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MemoryDecompressionMethodFlagBitsEXT value )
|
|
|
10533 {
|
|
|
10534 switch ( value )
|
|
|
10535 {
|
|
|
10536 case MemoryDecompressionMethodFlagBitsEXT::eGdeflate10: return "Gdeflate10";
|
|
|
10537 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10538 }
|
|
|
10539 }
|
|
|
10540
|
|
|
10541 //=== VK_NV_display_stereo ===
|
|
|
10542
|
|
|
10543 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DisplaySurfaceStereoTypeNV value )
|
|
|
10544 {
|
|
|
10545 switch ( value )
|
|
|
10546 {
|
|
|
10547 case DisplaySurfaceStereoTypeNV::eNone : return "None";
|
|
|
10548 case DisplaySurfaceStereoTypeNV::eOnboardDin : return "OnboardDin";
|
|
|
10549 case DisplaySurfaceStereoTypeNV::eHdmi3D : return "Hdmi3D";
|
|
|
10550 case DisplaySurfaceStereoTypeNV::eInbandDisplayport: return "InbandDisplayport";
|
|
|
10551 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10552 }
|
|
|
10553 }
|
|
|
10554
|
|
|
10555 //=== VK_KHR_video_encode_intra_refresh ===
|
|
|
10556
|
|
|
10557 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeIntraRefreshModeFlagBitsKHR value )
|
|
|
10558 {
|
|
|
10559 switch ( value )
|
|
|
10560 {
|
|
|
10561 case VideoEncodeIntraRefreshModeFlagBitsKHR::eNone : return "None";
|
|
|
10562 case VideoEncodeIntraRefreshModeFlagBitsKHR::ePerPicturePartition: return "PerPicturePartition";
|
|
|
10563 case VideoEncodeIntraRefreshModeFlagBitsKHR::eBlockBased : return "BlockBased";
|
|
|
10564 case VideoEncodeIntraRefreshModeFlagBitsKHR::eBlockRowBased : return "BlockRowBased";
|
|
|
10565 case VideoEncodeIntraRefreshModeFlagBitsKHR::eBlockColumnBased : return "BlockColumnBased";
|
|
|
10566 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10567 }
|
|
|
10568 }
|
|
|
10569
|
|
|
10570 //=== VK_KHR_maintenance7 ===
|
|
|
10571
|
|
|
10572 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PhysicalDeviceLayeredApiKHR value )
|
|
|
10573 {
|
|
|
10574 switch ( value )
|
|
|
10575 {
|
|
|
10576 case PhysicalDeviceLayeredApiKHR::eVulkan : return "Vulkan";
|
|
|
10577 case PhysicalDeviceLayeredApiKHR::eD3D12 : return "D3D12";
|
|
|
10578 case PhysicalDeviceLayeredApiKHR::eMetal : return "Metal";
|
|
|
10579 case PhysicalDeviceLayeredApiKHR::eOpengl : return "Opengl";
|
|
|
10580 case PhysicalDeviceLayeredApiKHR::eOpengles: return "Opengles";
|
|
|
10581 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10582 }
|
|
|
10583 }
|
|
|
10584
|
|
|
10585 //=== VK_NV_cluster_acceleration_structure ===
|
|
|
10586
|
|
|
10587 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ClusterAccelerationStructureClusterFlagBitsNV value )
|
|
|
10588 {
|
|
|
10589 switch ( value )
|
|
|
10590 {
|
|
|
10591 case ClusterAccelerationStructureClusterFlagBitsNV::eAllowDisableOpacityMicromaps: return "AllowDisableOpacityMicromaps";
|
|
|
10592 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10593 }
|
|
|
10594 }
|
|
|
10595
|
|
|
10596 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ClusterAccelerationStructureGeometryFlagBitsNV value )
|
|
|
10597 {
|
|
|
10598 switch ( value )
|
|
|
10599 {
|
|
|
10600 case ClusterAccelerationStructureGeometryFlagBitsNV::eCullDisable : return "CullDisable";
|
|
|
10601 case ClusterAccelerationStructureGeometryFlagBitsNV::eNoDuplicateAnyhitInvocation: return "NoDuplicateAnyhitInvocation";
|
|
|
10602 case ClusterAccelerationStructureGeometryFlagBitsNV::eOpaque : return "Opaque";
|
|
|
10603 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10604 }
|
|
|
10605 }
|
|
|
10606
|
|
|
10607 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ClusterAccelerationStructureAddressResolutionFlagBitsNV value )
|
|
|
10608 {
|
|
|
10609 switch ( value )
|
|
|
10610 {
|
|
|
10611 case ClusterAccelerationStructureAddressResolutionFlagBitsNV::eNone : return "None";
|
|
|
10612 case ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedDstImplicitData: return "IndirectedDstImplicitData";
|
|
|
10613 case ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedScratchData : return "IndirectedScratchData";
|
|
|
10614 case ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedDstAddressArray: return "IndirectedDstAddressArray";
|
|
|
10615 case ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedDstSizesArray : return "IndirectedDstSizesArray";
|
|
|
10616 case ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedSrcInfosArray : return "IndirectedSrcInfosArray";
|
|
|
10617 case ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedSrcInfosCount : return "IndirectedSrcInfosCount";
|
|
|
10618 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10619 }
|
|
|
10620 }
|
|
|
10621
|
|
|
10622 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ClusterAccelerationStructureIndexFormatFlagBitsNV value )
|
|
|
10623 {
|
|
|
10624 switch ( value )
|
|
|
10625 {
|
|
|
10626 case ClusterAccelerationStructureIndexFormatFlagBitsNV::e8 : return "8";
|
|
|
10627 case ClusterAccelerationStructureIndexFormatFlagBitsNV::e16: return "16";
|
|
|
10628 case ClusterAccelerationStructureIndexFormatFlagBitsNV::e32: return "32";
|
|
|
10629 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10630 }
|
|
|
10631 }
|
|
|
10632
|
|
|
10633 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ClusterAccelerationStructureTypeNV value )
|
|
|
10634 {
|
|
|
10635 switch ( value )
|
|
|
10636 {
|
|
|
10637 case ClusterAccelerationStructureTypeNV::eClustersBottomLevel : return "ClustersBottomLevel";
|
|
|
10638 case ClusterAccelerationStructureTypeNV::eTriangleCluster : return "TriangleCluster";
|
|
|
10639 case ClusterAccelerationStructureTypeNV::eTriangleClusterTemplate: return "TriangleClusterTemplate";
|
|
|
10640 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10641 }
|
|
|
10642 }
|
|
|
10643
|
|
|
10644 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ClusterAccelerationStructureOpTypeNV value )
|
|
|
10645 {
|
|
|
10646 switch ( value )
|
|
|
10647 {
|
|
|
10648 case ClusterAccelerationStructureOpTypeNV::eMoveObjects : return "MoveObjects";
|
|
|
10649 case ClusterAccelerationStructureOpTypeNV::eBuildClustersBottomLevel : return "BuildClustersBottomLevel";
|
|
|
10650 case ClusterAccelerationStructureOpTypeNV::eBuildTriangleCluster : return "BuildTriangleCluster";
|
|
|
10651 case ClusterAccelerationStructureOpTypeNV::eBuildTriangleClusterTemplate: return "BuildTriangleClusterTemplate";
|
|
|
10652 case ClusterAccelerationStructureOpTypeNV::eInstantiateTriangleCluster : return "InstantiateTriangleCluster";
|
|
|
10653 case ClusterAccelerationStructureOpTypeNV::eGetClusterTemplateIndices : return "GetClusterTemplateIndices";
|
|
|
10654 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10655 }
|
|
|
10656 }
|
|
|
10657
|
|
|
10658 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ClusterAccelerationStructureOpModeNV value )
|
|
|
10659 {
|
|
|
10660 switch ( value )
|
|
|
10661 {
|
|
|
10662 case ClusterAccelerationStructureOpModeNV::eImplicitDestinations: return "ImplicitDestinations";
|
|
|
10663 case ClusterAccelerationStructureOpModeNV::eExplicitDestinations: return "ExplicitDestinations";
|
|
|
10664 case ClusterAccelerationStructureOpModeNV::eComputeSizes : return "ComputeSizes";
|
|
|
10665 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10666 }
|
|
|
10667 }
|
|
|
10668
|
|
|
10669 //=== VK_NV_partitioned_acceleration_structure ===
|
|
|
10670
|
|
|
10671 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PartitionedAccelerationStructureOpTypeNV value )
|
|
|
10672 {
|
|
|
10673 switch ( value )
|
|
|
10674 {
|
|
|
10675 case PartitionedAccelerationStructureOpTypeNV::eWriteInstance : return "WriteInstance";
|
|
|
10676 case PartitionedAccelerationStructureOpTypeNV::eUpdateInstance : return "UpdateInstance";
|
|
|
10677 case PartitionedAccelerationStructureOpTypeNV::eWritePartitionTranslation: return "WritePartitionTranslation";
|
|
|
10678 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10679 }
|
|
|
10680 }
|
|
|
10681
|
|
|
10682 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PartitionedAccelerationStructureInstanceFlagBitsNV value )
|
|
|
10683 {
|
|
|
10684 switch ( value )
|
|
|
10685 {
|
|
|
10686 case PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagTriangleFacingCullDisable: return "FlagTriangleFacingCullDisable";
|
|
|
10687 case PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagTriangleFlipFacing : return "FlagTriangleFlipFacing";
|
|
|
10688 case PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagForceOpaque : return "FlagForceOpaque";
|
|
|
10689 case PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagForceNoOpaque : return "FlagForceNoOpaque";
|
|
|
10690 case PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagEnableExplicitBoundingBox: return "FlagEnableExplicitBoundingBox";
|
|
|
10691 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10692 }
|
|
|
10693 }
|
|
|
10694
|
|
|
10695 //=== VK_EXT_device_generated_commands ===
|
|
|
10696
|
|
|
10697 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IndirectCommandsTokenTypeEXT value )
|
|
|
10698 {
|
|
|
10699 switch ( value )
|
|
|
10700 {
|
|
|
10701 case IndirectCommandsTokenTypeEXT::eExecutionSet : return "ExecutionSet";
|
|
|
10702 case IndirectCommandsTokenTypeEXT::ePushConstant : return "PushConstant";
|
|
|
10703 case IndirectCommandsTokenTypeEXT::eSequenceIndex : return "SequenceIndex";
|
|
|
10704 case IndirectCommandsTokenTypeEXT::eIndexBuffer : return "IndexBuffer";
|
|
|
10705 case IndirectCommandsTokenTypeEXT::eVertexBuffer : return "VertexBuffer";
|
|
|
10706 case IndirectCommandsTokenTypeEXT::eDrawIndexed : return "DrawIndexed";
|
|
|
10707 case IndirectCommandsTokenTypeEXT::eDraw : return "Draw";
|
|
|
10708 case IndirectCommandsTokenTypeEXT::eDrawIndexedCount : return "DrawIndexedCount";
|
|
|
10709 case IndirectCommandsTokenTypeEXT::eDrawCount : return "DrawCount";
|
|
|
10710 case IndirectCommandsTokenTypeEXT::eDispatch : return "Dispatch";
|
|
|
10711 case IndirectCommandsTokenTypeEXT::eDrawMeshTasksNV : return "DrawMeshTasksNV";
|
|
|
10712 case IndirectCommandsTokenTypeEXT::eDrawMeshTasksCountNV: return "DrawMeshTasksCountNV";
|
|
|
10713 case IndirectCommandsTokenTypeEXT::eDrawMeshTasks : return "DrawMeshTasks";
|
|
|
10714 case IndirectCommandsTokenTypeEXT::eDrawMeshTasksCount : return "DrawMeshTasksCount";
|
|
|
10715 case IndirectCommandsTokenTypeEXT::eTraceRays2 : return "TraceRays2";
|
|
|
10716 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10717 }
|
|
|
10718 }
|
|
|
10719
|
|
|
10720 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IndirectExecutionSetInfoTypeEXT value )
|
|
|
10721 {
|
|
|
10722 switch ( value )
|
|
|
10723 {
|
|
|
10724 case IndirectExecutionSetInfoTypeEXT::ePipelines : return "Pipelines";
|
|
|
10725 case IndirectExecutionSetInfoTypeEXT::eShaderObjects: return "ShaderObjects";
|
|
|
10726 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10727 }
|
|
|
10728 }
|
|
|
10729
|
|
|
10730 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IndirectCommandsLayoutUsageFlagBitsEXT value )
|
|
|
10731 {
|
|
|
10732 switch ( value )
|
|
|
10733 {
|
|
|
10734 case IndirectCommandsLayoutUsageFlagBitsEXT::eExplicitPreprocess: return "ExplicitPreprocess";
|
|
|
10735 case IndirectCommandsLayoutUsageFlagBitsEXT::eUnorderedSequences: return "UnorderedSequences";
|
|
|
10736 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10737 }
|
|
|
10738 }
|
|
|
10739
|
|
|
10740 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IndirectCommandsInputModeFlagBitsEXT value )
|
|
|
10741 {
|
|
|
10742 switch ( value )
|
|
|
10743 {
|
|
|
10744 case IndirectCommandsInputModeFlagBitsEXT::eVulkanIndexBuffer: return "VulkanIndexBuffer";
|
|
|
10745 case IndirectCommandsInputModeFlagBitsEXT::eDxgiIndexBuffer : return "DxgiIndexBuffer";
|
|
|
10746 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10747 }
|
|
|
10748 }
|
|
|
10749
|
|
|
10750 //=== VK_KHR_maintenance8 ===
|
|
|
10751
|
|
|
10752 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccessFlagBits3KHR value )
|
|
|
10753 {
|
|
|
10754 switch ( value )
|
|
|
10755 {
|
|
|
10756 case AccessFlagBits3KHR::eNone: return "None";
|
|
|
10757 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10758 }
|
|
|
10759 }
|
|
|
10760
|
|
|
10761 //=== VK_EXT_ray_tracing_invocation_reorder ===
|
|
|
10762
|
|
|
10763 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( RayTracingInvocationReorderModeEXT value )
|
|
|
10764 {
|
|
|
10765 switch ( value )
|
|
|
10766 {
|
|
|
10767 case RayTracingInvocationReorderModeEXT::eNone : return "None";
|
|
|
10768 case RayTracingInvocationReorderModeEXT::eReorder: return "Reorder";
|
|
|
10769 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10770 }
|
|
|
10771 }
|
|
|
10772
|
|
|
10773 //=== VK_EXT_depth_clamp_control ===
|
|
|
10774
|
|
|
10775 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DepthClampModeEXT value )
|
|
|
10776 {
|
|
|
10777 switch ( value )
|
|
|
10778 {
|
|
|
10779 case DepthClampModeEXT::eViewportRange : return "ViewportRange";
|
|
|
10780 case DepthClampModeEXT::eUserDefinedRange: return "UserDefinedRange";
|
|
|
10781 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10782 }
|
|
|
10783 }
|
|
|
10784
|
|
|
10785 //=== VK_KHR_maintenance9 ===
|
|
|
10786
|
|
|
10787 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DefaultVertexAttributeValueKHR value )
|
|
|
10788 {
|
|
|
10789 switch ( value )
|
|
|
10790 {
|
|
|
10791 case DefaultVertexAttributeValueKHR::eZeroZeroZeroZero: return "ZeroZeroZeroZero";
|
|
|
10792 case DefaultVertexAttributeValueKHR::eZeroZeroZeroOne : return "ZeroZeroZeroOne";
|
|
|
10793 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10794 }
|
|
|
10795 }
|
|
|
10796
|
|
|
10797 #if defined( VK_USE_PLATFORM_OHOS )
|
|
|
10798 //=== VK_OHOS_surface ===
|
|
|
10799
|
|
|
10800 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SurfaceCreateFlagBitsOHOS )
|
|
|
10801 {
|
|
|
10802 return "(void)";
|
|
|
10803 }
|
|
|
10804 #endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
10805
|
|
|
10806 #if defined( VK_USE_PLATFORM_OHOS )
|
|
|
10807 //=== VK_OHOS_native_buffer ===
|
|
|
10808
|
|
|
10809 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SwapchainImageUsageFlagBitsOHOS value )
|
|
|
10810 {
|
|
|
10811 switch ( value )
|
|
|
10812 {
|
|
|
10813 case SwapchainImageUsageFlagBitsOHOS::eShared: return "Shared";
|
|
|
10814 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10815 }
|
|
|
10816 }
|
|
|
10817 #endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
10818
|
|
|
10819 //=== VK_ARM_performance_counters_by_region ===
|
|
|
10820
|
|
|
10821 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceCounterDescriptionFlagBitsARM )
|
|
|
10822 {
|
|
|
10823 return "(void)";
|
|
|
10824 }
|
|
|
10825
|
|
|
10826 //=== VK_QCOM_data_graph_model ===
|
|
|
10827
|
|
|
10828 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphModelCacheTypeQCOM value )
|
|
|
10829 {
|
|
|
10830 switch ( value )
|
|
|
10831 {
|
|
|
10832 case DataGraphModelCacheTypeQCOM::eGenericBinary: return "GenericBinary";
|
|
|
10833 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10834 }
|
|
|
10835 }
|
|
|
10836
|
|
|
10837 //=== VK_KHR_maintenance10 ===
|
|
|
10838
|
|
|
10839 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( RenderingAttachmentFlagBitsKHR value )
|
|
|
10840 {
|
|
|
10841 switch ( value )
|
|
|
10842 {
|
|
|
10843 case RenderingAttachmentFlagBitsKHR::eInputAttachmentFeedback : return "InputAttachmentFeedback";
|
|
|
10844 case RenderingAttachmentFlagBitsKHR::eResolveSkipTransferFunction : return "ResolveSkipTransferFunction";
|
|
|
10845 case RenderingAttachmentFlagBitsKHR::eResolveEnableTransferFunction: return "ResolveEnableTransferFunction";
|
|
|
10846 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10847 }
|
|
|
10848 }
|
|
|
10849
|
|
|
10850 VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ResolveImageFlagBitsKHR value )
|
|
|
10851 {
|
|
|
10852 switch ( value )
|
|
|
10853 {
|
|
|
10854 case ResolveImageFlagBitsKHR::eSkipTransferFunction : return "SkipTransferFunction";
|
|
|
10855 case ResolveImageFlagBitsKHR::eEnableTransferFunction: return "EnableTransferFunction";
|
|
|
10856 default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
|
|
|
10857 }
|
|
|
10858 }
|
|
|
10859
|
|
|
10860 } // namespace VULKAN_HPP_NAMESPACE
|
|
|
10861
|
|
|
10862 #if defined( __clang__ ) || defined( __GNUC__ )
|
|
|
10863 # pragma GCC diagnostic pop
|
|
|
10864 #elif defined( _MSC_VER )
|
|
|
10865 # pragma warning( pop )
|
|
|
10866 #endif
|
|
|
10867
|
|
|
10868 #endif
|
