1
2 /*
3 * Copyright 2024 The Android Open Source Project
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 */
18
19 // clang-format off
20
21 #ifndef VK_USE_PLATFORM_ANDROID_KHR
22 #define VK_USE_PLATFORM_ANDROID_KHR
23 #endif
24
25 #include <cstddef>
26 #include <cstdarg>
27 #include <cstdio>
28 #include <cstring>
29 #include <cstdint>
30 #include <cassert>
31 #include <cmath>
32 #include <string>
33 #include <vector>
34 #include <algorithm>
35 #include <memory>
36 #include <map>
37 #include "vulkan_profiles.h"
38
39 #include <cstdio>
40
41 #ifndef VP_DEBUG_MESSAGE_CALLBACK
42 #if defined(ANDROID) || defined(__ANDROID__)
43 #include <android/log.h>
44 #define VP_DEBUG_MESSAGE_CALLBACK(MSG) __android_log_print(ANDROID_LOG_ERROR, "vkprofiles ERROR", "%s", MSG); \
45 __android_log_print(ANDROID_LOG_DEBUG, "vkprofiles WARNING", "%s", MSG)
46 #else
47 #define VP_DEBUG_MESSAGE_CALLBACK(MSG) fprintf(stderr, "%s\n", MSG)
48 #endif
49 #else
50 void VP_DEBUG_MESSAGE_CALLBACK(const char*);
51 #endif
52
53 #define VP_DEBUG_MSG(MSG) VP_DEBUG_MESSAGE_CALLBACK(MSG)
54 #define VP_DEBUG_MSGF(MSGFMT, ...) { char msg[1024]; snprintf(msg, sizeof(msg) - 1, (MSGFMT), __VA_ARGS__); VP_DEBUG_MESSAGE_CALLBACK(msg); }
55 #define VP_DEBUG_COND_MSG(COND, MSG) if (COND) VP_DEBUG_MSG(MSG)
56 #define VP_DEBUG_COND_MSGF(COND, MSGFMT, ...) if (COND) VP_DEBUG_MSGF(MSGFMT, __VA_ARGS__)
57
58 #include <string>
59
60 namespace detail {
61
vpGetDeviceAndDriverInfoString(VkPhysicalDevice physicalDevice,PFN_vkGetPhysicalDeviceProperties2KHR pfnGetPhysicalDeviceProperties2)62 VPAPI_ATTR std::string vpGetDeviceAndDriverInfoString(VkPhysicalDevice physicalDevice,
63 PFN_vkGetPhysicalDeviceProperties2KHR pfnGetPhysicalDeviceProperties2) {
64 VkPhysicalDeviceDriverPropertiesKHR driverProps{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR };
65 VkPhysicalDeviceProperties2KHR deviceProps{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, &driverProps };
66 pfnGetPhysicalDeviceProperties2(physicalDevice, &deviceProps);
67 return std::string("deviceName=") + std::string(&deviceProps.properties.deviceName[0])
68 + ", driverName=" + std::string(&driverProps.driverName[0])
69 + ", driverInfo=" + std::string(&driverProps.driverInfo[0]);
70 }
71
72 }
73
74 namespace detail {
75
76
FormatString(const char * message,...)77 VPAPI_ATTR std::string FormatString(const char* message, ...) {
78 std::size_t const STRING_BUFFER(4096);
79
80 assert(message != nullptr);
81 assert(strlen(message) >= 1 && strlen(message) < STRING_BUFFER);
82
83 char buffer[STRING_BUFFER];
84 va_list list;
85
86 va_start(list, message);
87 vsnprintf(buffer, STRING_BUFFER, message, list);
88 va_end(list);
89
90 return buffer;
91 }
92
vpGetStructure(const void * pNext,VkStructureType type)93 VPAPI_ATTR const void* vpGetStructure(const void* pNext, VkStructureType type) {
94 const VkBaseOutStructure* p = static_cast<const VkBaseOutStructure*>(pNext);
95 while (p != nullptr) {
96 if (p->sType == type) return p;
97 p = p->pNext;
98 }
99 return nullptr;
100 }
101
vpGetStructure(void * pNext,VkStructureType type)102 VPAPI_ATTR void* vpGetStructure(void* pNext, VkStructureType type) {
103 VkBaseOutStructure* p = static_cast<VkBaseOutStructure*>(pNext);
104 while (p != nullptr) {
105 if (p->sType == type) return p;
106 p = p->pNext;
107 }
108 return nullptr;
109 }
110
vpExtractStructure(VkPhysicalDeviceFeatures2KHR * pFeatures,VkStructureType structureType)111 VPAPI_ATTR VkBaseOutStructure* vpExtractStructure(VkPhysicalDeviceFeatures2KHR* pFeatures, VkStructureType structureType) {
112 if (structureType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR) {
113 return nullptr;
114 }
115
116 VkBaseOutStructure* current = reinterpret_cast<VkBaseOutStructure*>(pFeatures);
117 VkBaseOutStructure* previous = nullptr;
118 VkBaseOutStructure* found = nullptr;
119
120 while (current != nullptr) {
121 if (structureType == current->sType) {
122 found = current;
123 if (previous != nullptr) {
124 previous->pNext = current->pNext;
125 }
126 current = nullptr;
127 } else {
128 previous = current;
129 current = current->pNext;
130 }
131 }
132
133 if (found != nullptr) {
134 found->pNext = nullptr;
135 return found;
136 } else {
137 return nullptr;
138 }
139 }
140
GatherStructureTypes(std::vector<VkStructureType> & structureTypes,VkBaseOutStructure * pNext)141 VPAPI_ATTR void GatherStructureTypes(std::vector<VkStructureType>& structureTypes, VkBaseOutStructure* pNext) {
142 while (pNext) {
143 if (std::find(structureTypes.begin(), structureTypes.end(), pNext->sType) == structureTypes.end()) {
144 structureTypes.push_back(pNext->sType);
145 }
146
147 pNext = pNext->pNext;
148 }
149 }
150
isMultiple(double source,double multiple)151 VPAPI_ATTR bool isMultiple(double source, double multiple) {
152 double mod = std::fmod(source, multiple);
153 return std::abs(mod) < 0.0001;
154 }
155
isPowerOfTwo(double source)156 VPAPI_ATTR bool isPowerOfTwo(double source) {
157 double mod = std::fmod(source, 1.0);
158 if (std::abs(mod) >= 0.0001) return false;
159
160 std::uint64_t value = static_cast<std::uint64_t>(std::abs(source));
161 return !(value & (value - static_cast<std::uint64_t>(1)));
162 }
163
164 using PFN_vpStructFiller = void(*)(VkBaseOutStructure* p);
165 using PFN_vpStructComparator = bool(*)(VkBaseOutStructure* p);
166 using PFN_vpStructChainerCb = void(*)(VkBaseOutStructure* p, void* pUser);
167 using PFN_vpStructChainer = void(*)(VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb);
168 using PFN_vpStructArrayChainerCb = void(*)(uint32_t count, VkBaseOutStructure* p, void* pUser);
169 using PFN_vpStructArrayChainer = void(*)(uint32_t count, VkBaseOutStructure* p, void* pUser, PFN_vpStructArrayChainerCb pfnCb);
170
171 struct VpFeatureDesc {
172 PFN_vpStructFiller pfnFiller;
173 PFN_vpStructComparator pfnComparator;
174 };
175
176 struct VpPropertyDesc {
177 PFN_vpStructFiller pfnFiller;
178 PFN_vpStructComparator pfnComparator;
179 };
180
181 struct VpQueueFamilyDesc {
182 PFN_vpStructFiller pfnFiller;
183 PFN_vpStructComparator pfnComparator;
184 };
185
186 struct VpFormatDesc {
187 VkFormat format;
188 PFN_vpStructFiller pfnFiller;
189 PFN_vpStructComparator pfnComparator;
190 };
191
192 struct VpStructChainerDesc {
193 PFN_vpStructChainer pfnFeature;
194 PFN_vpStructChainer pfnProperty;
195 PFN_vpStructArrayChainer pfnQueueFamily;
196 PFN_vpStructChainer pfnFormat;
197 };
198
199 struct VpVideoProfileInfoDesc {
200 PFN_vpStructFiller pfnFiller;
201 PFN_vpStructComparator pfnComparator;
202 };
203
204 struct VpVideoCapabilityDesc {
205 PFN_vpStructFiller pfnFiller;
206 PFN_vpStructComparator pfnComparator;
207 };
208
209 struct VpVideoFormatDesc {
210 PFN_vpStructFiller pfnFiller;
211 PFN_vpStructComparator pfnComparator;
212 };
213
214 struct VpVideoProfileStructChainerDesc {
215 PFN_vpStructChainer pfnInfo;
216 PFN_vpStructChainer pfnCapability;
217 PFN_vpStructArrayChainer pfnFormat;
218 };
219
220 struct VpVideoProfileDesc {
221 VpVideoProfileProperties properties;
222
223 uint32_t infoStructTypeCount;
224 const VkStructureType* pInfoStructTypes;
225 VpVideoProfileInfoDesc info;
226
227 uint32_t capabilityStructTypeCount;
228 const VkStructureType* pCapabilityStructTypes;
229 VpVideoCapabilityDesc capability;
230
231 uint32_t formatStructTypeCount;
232 const VkStructureType* pFormatStructTypes;
233 uint32_t formatCount;
234 const VpVideoFormatDesc* pFormats;
235
236 VpVideoProfileStructChainerDesc chainers;
237 };
238
239 struct VpVariantDesc {
240 char blockName[VP_MAX_PROFILE_NAME_SIZE];
241
242 uint32_t instanceExtensionCount;
243 const VkExtensionProperties* pInstanceExtensions;
244
245 uint32_t deviceExtensionCount;
246 const VkExtensionProperties* pDeviceExtensions;
247
248 uint32_t featureStructTypeCount;
249 const VkStructureType* pFeatureStructTypes;
250 VpFeatureDesc feature;
251
252 uint32_t propertyStructTypeCount;
253 const VkStructureType* pPropertyStructTypes;
254 VpPropertyDesc property;
255
256 uint32_t queueFamilyStructTypeCount;
257 const VkStructureType* pQueueFamilyStructTypes;
258 uint32_t queueFamilyCount;
259 const VpQueueFamilyDesc* pQueueFamilies;
260
261 uint32_t formatStructTypeCount;
262 const VkStructureType* pFormatStructTypes;
263 uint32_t formatCount;
264 const VpFormatDesc* pFormats;
265
266 VpStructChainerDesc chainers;
267
268 uint32_t videoProfileCount;
269 const VpVideoProfileDesc* pVideoProfiles;
270 };
271
272 struct VpCapabilitiesDesc {
273 uint32_t variantCount;
274 const VpVariantDesc* pVariants;
275 };
276
277 struct VpProfileDesc {
278 VpProfileProperties props;
279 uint32_t minApiVersion;
280
281 const detail::VpVariantDesc* pMergedCapabilities;
282
283 uint32_t requiredProfileCount;
284 const VpProfileProperties* pRequiredProfiles;
285
286 uint32_t requiredCapabilityCount;
287 const VpCapabilitiesDesc* pRequiredCapabilities;
288
289 uint32_t fallbackCount;
290 const VpProfileProperties* pFallbacks;
291 };
292
293 template <typename T>
vpCheckFlags(const T & actual,const uint64_t expected)294 VPAPI_ATTR bool vpCheckFlags(const T& actual, const uint64_t expected) {
295 return (actual & expected) == expected;
296 }
297
298
299 #ifdef VK_KHR_video_queue
vpForEachMatchingVideoProfiles(VkVideoProfileInfoKHR * pVideoProfileInfo,void * pUser,PFN_vpStructChainerCb pfnCb)300 VPAPI_ATTR void vpForEachMatchingVideoProfiles(
301 VkVideoProfileInfoKHR* pVideoProfileInfo,
302 void* pUser,
303 PFN_vpStructChainerCb pfnCb) {
304 const VkVideoChromaSubsamplingFlagsKHR chroma_subsampling_list[] = {
305 VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR,
306 VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR,
307 VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR,
308 VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR
309 };
310 const VkVideoComponentBitDepthFlagsKHR bit_depth_list[] = {
311 VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR,
312 VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR,
313 VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR
314 };
315 for (size_t chromaSubsampling_idx = 0; chromaSubsampling_idx < std::size(chroma_subsampling_list); ++chromaSubsampling_idx) {
316 pVideoProfileInfo->chromaSubsampling = chroma_subsampling_list[chromaSubsampling_idx];
317 for (size_t lumaBitDepth_idx = 0; lumaBitDepth_idx < std::size(bit_depth_list); ++lumaBitDepth_idx) {
318 pVideoProfileInfo->lumaBitDepth = bit_depth_list[lumaBitDepth_idx];
319 for (size_t chromaBitDepth_idx = 0; chromaBitDepth_idx < std::size(bit_depth_list); ++chromaBitDepth_idx) {
320 pVideoProfileInfo->chromaBitDepth = bit_depth_list[chromaBitDepth_idx];
321 {
322 pVideoProfileInfo->pNext = nullptr;
323 pVideoProfileInfo->videoCodecOperation = VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR;
324 VkVideoDecodeH264ProfileInfoKHR var_VideoDecodeH264ProfileInfoKHR = { VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR };
325 var_VideoDecodeH264ProfileInfoKHR.pNext = pVideoProfileInfo->pNext;
326 pVideoProfileInfo->pNext = &var_VideoDecodeH264ProfileInfoKHR;
327 var_VideoDecodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_BASELINE;
328 var_VideoDecodeH264ProfileInfoKHR.pictureLayout = VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR;
329 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
330 var_VideoDecodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_MAIN;
331 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
332 var_VideoDecodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_HIGH;
333 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
334 var_VideoDecodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE;
335 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
336 var_VideoDecodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_BASELINE;
337 var_VideoDecodeH264ProfileInfoKHR.pictureLayout = VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR;
338 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
339 var_VideoDecodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_MAIN;
340 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
341 var_VideoDecodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_HIGH;
342 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
343 var_VideoDecodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE;
344 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
345 var_VideoDecodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_BASELINE;
346 var_VideoDecodeH264ProfileInfoKHR.pictureLayout = VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR;
347 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
348 var_VideoDecodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_MAIN;
349 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
350 var_VideoDecodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_HIGH;
351 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
352 var_VideoDecodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE;
353 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
354 }
355 {
356 pVideoProfileInfo->pNext = nullptr;
357 pVideoProfileInfo->videoCodecOperation = VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR;
358 VkVideoDecodeH265ProfileInfoKHR var_VideoDecodeH265ProfileInfoKHR = { VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR };
359 var_VideoDecodeH265ProfileInfoKHR.pNext = pVideoProfileInfo->pNext;
360 pVideoProfileInfo->pNext = &var_VideoDecodeH265ProfileInfoKHR;
361 var_VideoDecodeH265ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H265_PROFILE_IDC_MAIN;
362 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
363 var_VideoDecodeH265ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H265_PROFILE_IDC_MAIN_10;
364 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
365 var_VideoDecodeH265ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE;
366 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
367 var_VideoDecodeH265ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS;
368 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
369 var_VideoDecodeH265ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS;
370 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
371 }
372 {
373 pVideoProfileInfo->pNext = nullptr;
374 pVideoProfileInfo->videoCodecOperation = VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR;
375 VkVideoDecodeAV1ProfileInfoKHR var_VideoDecodeAV1ProfileInfoKHR = { VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR };
376 var_VideoDecodeAV1ProfileInfoKHR.pNext = pVideoProfileInfo->pNext;
377 pVideoProfileInfo->pNext = &var_VideoDecodeAV1ProfileInfoKHR;
378 var_VideoDecodeAV1ProfileInfoKHR.stdProfile = STD_VIDEO_AV1_PROFILE_MAIN;
379 var_VideoDecodeAV1ProfileInfoKHR.filmGrainSupport = VK_TRUE;
380 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
381 var_VideoDecodeAV1ProfileInfoKHR.stdProfile = STD_VIDEO_AV1_PROFILE_HIGH;
382 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
383 var_VideoDecodeAV1ProfileInfoKHR.stdProfile = STD_VIDEO_AV1_PROFILE_PROFESSIONAL;
384 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
385 var_VideoDecodeAV1ProfileInfoKHR.stdProfile = STD_VIDEO_AV1_PROFILE_MAIN;
386 var_VideoDecodeAV1ProfileInfoKHR.filmGrainSupport = VK_FALSE;
387 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
388 var_VideoDecodeAV1ProfileInfoKHR.stdProfile = STD_VIDEO_AV1_PROFILE_HIGH;
389 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
390 var_VideoDecodeAV1ProfileInfoKHR.stdProfile = STD_VIDEO_AV1_PROFILE_PROFESSIONAL;
391 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
392 }
393 {
394 pVideoProfileInfo->pNext = nullptr;
395 pVideoProfileInfo->videoCodecOperation = VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR;
396 VkVideoEncodeH264ProfileInfoKHR var_VideoEncodeH264ProfileInfoKHR = { VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR };
397 var_VideoEncodeH264ProfileInfoKHR.pNext = pVideoProfileInfo->pNext;
398 pVideoProfileInfo->pNext = &var_VideoEncodeH264ProfileInfoKHR;
399 var_VideoEncodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_BASELINE;
400 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
401 var_VideoEncodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_MAIN;
402 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
403 var_VideoEncodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_HIGH;
404 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
405 var_VideoEncodeH264ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE;
406 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
407 }
408 {
409 pVideoProfileInfo->pNext = nullptr;
410 pVideoProfileInfo->videoCodecOperation = VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR;
411 VkVideoEncodeH265ProfileInfoKHR var_VideoEncodeH265ProfileInfoKHR = { VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR };
412 var_VideoEncodeH265ProfileInfoKHR.pNext = pVideoProfileInfo->pNext;
413 pVideoProfileInfo->pNext = &var_VideoEncodeH265ProfileInfoKHR;
414 var_VideoEncodeH265ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H265_PROFILE_IDC_MAIN;
415 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
416 var_VideoEncodeH265ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H265_PROFILE_IDC_MAIN_10;
417 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
418 var_VideoEncodeH265ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE;
419 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
420 var_VideoEncodeH265ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS;
421 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
422 var_VideoEncodeH265ProfileInfoKHR.stdProfileIdc = STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS;
423 pfnCb(reinterpret_cast<VkBaseOutStructure*>(pVideoProfileInfo), pUser);
424 }
425 }
426 }
427 }
428 }
429 #endif // VK_KHR_video_queue
430 #ifdef VP_ANDROID_15_minimums
431 namespace VP_ANDROID_15_MINIMUMS {
432
433 static const VkStructureType featureStructTypes[] = {
434 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR,
435 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES,
436 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT,
437 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT,
438 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT,
439 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT,
440 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR,
441 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES,
442 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES,
443 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES,
444 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES,
445 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES,
446 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT,
447 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT,
448 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG,
449 };
450
451 static const VkStructureType propertyStructTypes[] = {
452 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR,
453 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES,
454 };
455
456 static const VkStructureType formatStructTypes[] = {
457 VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR,
458 VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR,
459 };
460
461 namespace blocks {
462 namespace MUST {
463
464 static const VkExtensionProperties instanceExtensions[] = {
465 VkExtensionProperties{ VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME, 1 },
466 VkExtensionProperties{ VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME, 1 },
467 };
468
469 static const VkExtensionProperties deviceExtensions[] = {
470 VkExtensionProperties{ VK_ANDROID_EXTERNAL_FORMAT_RESOLVE_EXTENSION_NAME, 1 },
471 VkExtensionProperties{ VK_EXT_4444_FORMATS_EXTENSION_NAME, 1 },
472 VkExtensionProperties{ VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME, 1 },
473 VkExtensionProperties{ VK_EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME, 1 },
474 VkExtensionProperties{ VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXTENSION_NAME, 1 },
475 VkExtensionProperties{ VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME, 1 },
476 VkExtensionProperties{ VK_EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME, 1 },
477 VkExtensionProperties{ VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME, 1 },
478 VkExtensionProperties{ VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME, 1 },
479 VkExtensionProperties{ VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME, 1 },
480 VkExtensionProperties{ VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME, 1 },
481 VkExtensionProperties{ VK_KHR_16BIT_STORAGE_EXTENSION_NAME, 1 },
482 VkExtensionProperties{ VK_KHR_MAINTENANCE_5_EXTENSION_NAME, 1 },
483 VkExtensionProperties{ VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME, 1 },
484 VkExtensionProperties{ VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME, 1 },
485 };
486
487 static const VpFeatureDesc featureDesc = {
__anon3431b7520102() 488 [](VkBaseOutStructure* p) { (void)p;
489 switch (p->sType) {
490 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: {
491 VkPhysicalDeviceFeatures2KHR* s = static_cast<VkPhysicalDeviceFeatures2KHR*>(static_cast<void*>(p));
492 s->features.drawIndirectFirstInstance = VK_TRUE;
493 s->features.samplerAnisotropy = VK_TRUE;
494 s->features.shaderImageGatherExtended = VK_TRUE;
495 s->features.shaderStorageImageExtendedFormats = VK_TRUE;
496 s->features.shaderStorageImageReadWithoutFormat = VK_TRUE;
497 s->features.shaderStorageImageWriteWithoutFormat = VK_TRUE;
498 } break;
499 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: {
500 VkPhysicalDeviceVulkan12Features* s = static_cast<VkPhysicalDeviceVulkan12Features*>(static_cast<void*>(p));
501 s->shaderFloat16 = VK_TRUE;
502 s->shaderInt8 = VK_TRUE;
503 } break;
504 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: {
505 VkPhysicalDeviceCustomBorderColorFeaturesEXT* s = static_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(static_cast<void*>(p));
506 s->customBorderColors = VK_TRUE;
507 } break;
508 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: {
509 VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* s = static_cast<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(static_cast<void*>(p));
510 s->primitiveTopologyListRestart = VK_TRUE;
511 } break;
512 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: {
513 VkPhysicalDeviceProvokingVertexFeaturesEXT* s = static_cast<VkPhysicalDeviceProvokingVertexFeaturesEXT*>(static_cast<void*>(p));
514 s->provokingVertexLast = VK_TRUE;
515 } break;
516 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: {
517 VkPhysicalDeviceIndexTypeUint8FeaturesEXT* s = static_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(static_cast<void*>(p));
518 s->indexTypeUint8 = VK_TRUE;
519 } break;
520 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: {
521 VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* s = static_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR*>(static_cast<void*>(p));
522 s->vertexAttributeInstanceRateDivisor = VK_TRUE;
523 } break;
524 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: {
525 VkPhysicalDeviceSamplerYcbcrConversionFeatures* s = static_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(static_cast<void*>(p));
526 s->samplerYcbcrConversion = VK_TRUE;
527 } break;
528 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: {
529 VkPhysicalDeviceShaderFloat16Int8Features* s = static_cast<VkPhysicalDeviceShaderFloat16Int8Features*>(static_cast<void*>(p));
530 s->shaderFloat16 = VK_TRUE;
531 s->shaderInt8 = VK_TRUE;
532 } break;
533 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: {
534 VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* s = static_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(static_cast<void*>(p));
535 s->shaderSubgroupExtendedTypes = VK_TRUE;
536 } break;
537 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: {
538 VkPhysicalDevice8BitStorageFeatures* s = static_cast<VkPhysicalDevice8BitStorageFeatures*>(static_cast<void*>(p));
539 s->storageBuffer8BitAccess = VK_TRUE;
540 } break;
541 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: {
542 VkPhysicalDevice16BitStorageFeatures* s = static_cast<VkPhysicalDevice16BitStorageFeatures*>(static_cast<void*>(p));
543 s->storageBuffer16BitAccess = VK_TRUE;
544 } break;
545 default: break;
546 }
547 },
__anon3431b7520202() 548 [](VkBaseOutStructure* p) -> bool { (void)p;
549 bool ret = true;
550 switch (p->sType) {
551 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: {
552 VkPhysicalDeviceFeatures2KHR* s = static_cast<VkPhysicalDeviceFeatures2KHR*>(static_cast<void*>(p));
553 ret = ret && (s->features.drawIndirectFirstInstance == VK_TRUE);
554 ret = ret && (s->features.samplerAnisotropy == VK_TRUE);
555 ret = ret && (s->features.shaderImageGatherExtended == VK_TRUE);
556 ret = ret && (s->features.shaderStorageImageExtendedFormats == VK_TRUE);
557 ret = ret && (s->features.shaderStorageImageReadWithoutFormat == VK_TRUE);
558 ret = ret && (s->features.shaderStorageImageWriteWithoutFormat == VK_TRUE);
559 } break;
560 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: {
561 VkPhysicalDeviceVulkan12Features* s = static_cast<VkPhysicalDeviceVulkan12Features*>(static_cast<void*>(p));
562 ret = ret && (s->shaderFloat16 == VK_TRUE);
563 ret = ret && (s->shaderInt8 == VK_TRUE);
564 } break;
565 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: {
566 VkPhysicalDeviceCustomBorderColorFeaturesEXT* s = static_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(static_cast<void*>(p));
567 ret = ret && (s->customBorderColors == VK_TRUE);
568 } break;
569 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: {
570 VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* s = static_cast<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(static_cast<void*>(p));
571 ret = ret && (s->primitiveTopologyListRestart == VK_TRUE);
572 } break;
573 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: {
574 VkPhysicalDeviceProvokingVertexFeaturesEXT* s = static_cast<VkPhysicalDeviceProvokingVertexFeaturesEXT*>(static_cast<void*>(p));
575 ret = ret && (s->provokingVertexLast == VK_TRUE);
576 } break;
577 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: {
578 VkPhysicalDeviceIndexTypeUint8FeaturesEXT* s = static_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(static_cast<void*>(p));
579 ret = ret && (s->indexTypeUint8 == VK_TRUE);
580 } break;
581 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: {
582 VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* s = static_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR*>(static_cast<void*>(p));
583 ret = ret && (s->vertexAttributeInstanceRateDivisor == VK_TRUE);
584 } break;
585 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: {
586 VkPhysicalDeviceSamplerYcbcrConversionFeatures* s = static_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(static_cast<void*>(p));
587 ret = ret && (s->samplerYcbcrConversion == VK_TRUE);
588 } break;
589 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: {
590 VkPhysicalDeviceShaderFloat16Int8Features* s = static_cast<VkPhysicalDeviceShaderFloat16Int8Features*>(static_cast<void*>(p));
591 ret = ret && (s->shaderFloat16 == VK_TRUE);
592 ret = ret && (s->shaderInt8 == VK_TRUE);
593 } break;
594 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: {
595 VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* s = static_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(static_cast<void*>(p));
596 ret = ret && (s->shaderSubgroupExtendedTypes == VK_TRUE);
597 } break;
598 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: {
599 VkPhysicalDevice8BitStorageFeatures* s = static_cast<VkPhysicalDevice8BitStorageFeatures*>(static_cast<void*>(p));
600 ret = ret && (s->storageBuffer8BitAccess == VK_TRUE);
601 } break;
602 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: {
603 VkPhysicalDevice16BitStorageFeatures* s = static_cast<VkPhysicalDevice16BitStorageFeatures*>(static_cast<void*>(p));
604 ret = ret && (s->storageBuffer16BitAccess == VK_TRUE);
605 } break;
606 default: break;
607 }
608 return ret;
609 }
610 };
611
612 static const VpPropertyDesc propertyDesc = {
__anon3431b7520302() 613 [](VkBaseOutStructure* p) { (void)p;
614 switch (p->sType) {
615 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: {
616 VkPhysicalDeviceProperties2KHR* s = static_cast<VkPhysicalDeviceProperties2KHR*>(static_cast<void*>(p));
617 s->properties.limits.maxColorAttachments = 8;
618 s->properties.limits.maxPerStageDescriptorSampledImages = 128;
619 s->properties.limits.maxPerStageDescriptorSamplers = 128;
620 s->properties.limits.maxPerStageDescriptorStorageBuffers = 12;
621 s->properties.limits.maxPerStageDescriptorUniformBuffers = 13;
622 } break;
623 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: {
624 VkPhysicalDeviceVulkan11Properties* s = static_cast<VkPhysicalDeviceVulkan11Properties*>(static_cast<void*>(p));
625 s->subgroupSupportedOperations |= (VK_SUBGROUP_FEATURE_BASIC_BIT | VK_SUBGROUP_FEATURE_VOTE_BIT | VK_SUBGROUP_FEATURE_ARITHMETIC_BIT | VK_SUBGROUP_FEATURE_BALLOT_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT);
626 } break;
627 default: break;
628 }
629 },
__anon3431b7520402() 630 [](VkBaseOutStructure* p) -> bool { (void)p;
631 bool ret = true;
632 switch (p->sType) {
633 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: {
634 VkPhysicalDeviceProperties2KHR* s = static_cast<VkPhysicalDeviceProperties2KHR*>(static_cast<void*>(p));
635 ret = ret && (s->properties.limits.maxColorAttachments >= 8);
636 ret = ret && (s->properties.limits.maxPerStageDescriptorSampledImages >= 128);
637 ret = ret && (s->properties.limits.maxPerStageDescriptorSamplers >= 128);
638 ret = ret && (s->properties.limits.maxPerStageDescriptorStorageBuffers >= 12);
639 ret = ret && (s->properties.limits.maxPerStageDescriptorUniformBuffers >= 13);
640 } break;
641 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: {
642 VkPhysicalDeviceVulkan11Properties* s = static_cast<VkPhysicalDeviceVulkan11Properties*>(static_cast<void*>(p));
643 ret = ret && (vpCheckFlags(s->subgroupSupportedOperations, (VK_SUBGROUP_FEATURE_BASIC_BIT | VK_SUBGROUP_FEATURE_VOTE_BIT | VK_SUBGROUP_FEATURE_ARITHMETIC_BIT | VK_SUBGROUP_FEATURE_BALLOT_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT)));
644 } break;
645 default: break;
646 }
647 return ret;
648 }
649 };
650
651 static const VpFormatDesc formatDesc[] = {
652 {
653 VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT,
__anon3431b7520502() 654 [](VkBaseOutStructure* p) { (void)p;
655 switch (p->sType) {
656 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
657 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
658 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
659 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
660 } break;
661 default: break;
662 }
663 },
__anon3431b7520602() 664 [](VkBaseOutStructure* p) -> bool { (void)p;
665 bool ret = true;
666 switch (p->sType) {
667 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
668 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
669 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
670 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
671 } break;
672 default: break;
673 }
674 return ret;
675 }
676 },
677 {
678 VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT,
__anon3431b7520702() 679 [](VkBaseOutStructure* p) { (void)p;
680 switch (p->sType) {
681 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
682 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
683 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
684 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
685 } break;
686 default: break;
687 }
688 },
__anon3431b7520802() 689 [](VkBaseOutStructure* p) -> bool { (void)p;
690 bool ret = true;
691 switch (p->sType) {
692 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
693 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
694 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
695 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
696 } break;
697 default: break;
698 }
699 return ret;
700 }
701 },
702 };
703
704 static const VpStructChainerDesc chainerDesc = {
__anon3431b7520902() 705 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
706 VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, nullptr };
707 VkPhysicalDeviceCustomBorderColorFeaturesEXT physicalDeviceCustomBorderColorFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, &physicalDeviceVulkan12Features };
708 VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT physicalDevicePrimitiveTopologyListRestartFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT, &physicalDeviceCustomBorderColorFeaturesEXT };
709 VkPhysicalDeviceProvokingVertexFeaturesEXT physicalDeviceProvokingVertexFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT, &physicalDevicePrimitiveTopologyListRestartFeaturesEXT };
710 VkPhysicalDeviceIndexTypeUint8FeaturesEXT physicalDeviceIndexTypeUint8FeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, &physicalDeviceProvokingVertexFeaturesEXT };
711 VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR physicalDeviceVertexAttributeDivisorFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR, &physicalDeviceIndexTypeUint8FeaturesEXT };
712 VkPhysicalDeviceSamplerYcbcrConversionFeatures physicalDeviceSamplerYcbcrConversionFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, &physicalDeviceVertexAttributeDivisorFeaturesKHR };
713 VkPhysicalDeviceShaderFloat16Int8Features physicalDeviceShaderFloat16Int8Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, &physicalDeviceSamplerYcbcrConversionFeatures };
714 VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures physicalDeviceShaderSubgroupExtendedTypesFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, &physicalDeviceShaderFloat16Int8Features };
715 VkPhysicalDevice8BitStorageFeatures physicalDevice8BitStorageFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, &physicalDeviceShaderSubgroupExtendedTypesFeatures };
716 VkPhysicalDevice16BitStorageFeatures physicalDevice16BitStorageFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, &physicalDevice8BitStorageFeatures };
717 VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT physicalDevicePrimitivesGeneratedQueryFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT, &physicalDevice16BitStorageFeatures };
718 VkPhysicalDeviceLineRasterizationFeaturesEXT physicalDeviceLineRasterizationFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, &physicalDevicePrimitivesGeneratedQueryFeaturesEXT };
719 VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG physicalDeviceRelaxedLineRasterizationFeaturesIMG{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG, &physicalDeviceLineRasterizationFeaturesEXT };
720 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(&physicalDeviceRelaxedLineRasterizationFeaturesIMG));
721 pfnCb(p, pUser);
722 },
__anon3431b7520a02() 723 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
724 VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr };
725 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(&physicalDeviceVulkan11Properties));
726 pfnCb(p, pUser);
727 },
__anon3431b7520b02() 728 [](uint32_t count, VkBaseOutStructure* p, void* pUser, PFN_vpStructArrayChainerCb pfnCb) {
729 pfnCb(count, p, pUser);
730 },
__anon3431b7520c02() 731 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
732 VkFormatProperties3KHR formatProperties3KHR{ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr };
733 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(&formatProperties3KHR));
734 pfnCb(p, pUser);
735 },
736 };
737 } // namespace MUST
738 namespace primitivesGeneratedQuery {
739
740 static const VkExtensionProperties deviceExtensions[] = {
741 VkExtensionProperties{ VK_EXT_PRIMITIVES_GENERATED_QUERY_EXTENSION_NAME, 1 },
742 };
743
744 static const VpFeatureDesc featureDesc = {
__anon3431b7520d02() 745 [](VkBaseOutStructure* p) { (void)p;
746 switch (p->sType) {
747 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: {
748 VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* s = static_cast<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(static_cast<void*>(p));
749 s->primitivesGeneratedQuery = VK_TRUE;
750 } break;
751 default: break;
752 }
753 },
__anon3431b7520e02() 754 [](VkBaseOutStructure* p) -> bool { (void)p;
755 bool ret = true;
756 switch (p->sType) {
757 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: {
758 VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* s = static_cast<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(static_cast<void*>(p));
759 ret = ret && (s->primitivesGeneratedQuery == VK_TRUE);
760 } break;
761 default: break;
762 }
763 return ret;
764 }
765 };
766
767 static const VpPropertyDesc propertyDesc = {
__anon3431b7520f02() 768 [](VkBaseOutStructure* p) { (void)p;
769 },
__anon3431b7521002() 770 [](VkBaseOutStructure* p) -> bool { (void)p;
771 bool ret = true;
772 return ret;
773 }
774 };
775
776 static const VpStructChainerDesc chainerDesc = {
__anon3431b7521102() 777 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
778 VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, nullptr };
779 VkPhysicalDeviceCustomBorderColorFeaturesEXT physicalDeviceCustomBorderColorFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, &physicalDeviceVulkan12Features };
780 VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT physicalDevicePrimitiveTopologyListRestartFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT, &physicalDeviceCustomBorderColorFeaturesEXT };
781 VkPhysicalDeviceProvokingVertexFeaturesEXT physicalDeviceProvokingVertexFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT, &physicalDevicePrimitiveTopologyListRestartFeaturesEXT };
782 VkPhysicalDeviceIndexTypeUint8FeaturesEXT physicalDeviceIndexTypeUint8FeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, &physicalDeviceProvokingVertexFeaturesEXT };
783 VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR physicalDeviceVertexAttributeDivisorFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR, &physicalDeviceIndexTypeUint8FeaturesEXT };
784 VkPhysicalDeviceSamplerYcbcrConversionFeatures physicalDeviceSamplerYcbcrConversionFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, &physicalDeviceVertexAttributeDivisorFeaturesKHR };
785 VkPhysicalDeviceShaderFloat16Int8Features physicalDeviceShaderFloat16Int8Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, &physicalDeviceSamplerYcbcrConversionFeatures };
786 VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures physicalDeviceShaderSubgroupExtendedTypesFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, &physicalDeviceShaderFloat16Int8Features };
787 VkPhysicalDevice8BitStorageFeatures physicalDevice8BitStorageFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, &physicalDeviceShaderSubgroupExtendedTypesFeatures };
788 VkPhysicalDevice16BitStorageFeatures physicalDevice16BitStorageFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, &physicalDevice8BitStorageFeatures };
789 VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT physicalDevicePrimitivesGeneratedQueryFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT, &physicalDevice16BitStorageFeatures };
790 VkPhysicalDeviceLineRasterizationFeaturesEXT physicalDeviceLineRasterizationFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, &physicalDevicePrimitivesGeneratedQueryFeaturesEXT };
791 VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG physicalDeviceRelaxedLineRasterizationFeaturesIMG{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG, &physicalDeviceLineRasterizationFeaturesEXT };
792 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(&physicalDeviceRelaxedLineRasterizationFeaturesIMG));
793 pfnCb(p, pUser);
794 },
__anon3431b7521202() 795 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
796 VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr };
797 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(&physicalDeviceVulkan11Properties));
798 pfnCb(p, pUser);
799 },
__anon3431b7521302() 800 [](uint32_t count, VkBaseOutStructure* p, void* pUser, PFN_vpStructArrayChainerCb pfnCb) {
801 pfnCb(count, p, pUser);
802 },
__anon3431b7521402() 803 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
804 VkFormatProperties3KHR formatProperties3KHR{ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr };
805 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(&formatProperties3KHR));
806 pfnCb(p, pUser);
807 },
808 };
809 } // namespace primitivesGeneratedQuery
810 namespace pipelineStatisticsQuery {
811
812 static const VpFeatureDesc featureDesc = {
__anon3431b7521502() 813 [](VkBaseOutStructure* p) { (void)p;
814 switch (p->sType) {
815 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: {
816 VkPhysicalDeviceFeatures2KHR* s = static_cast<VkPhysicalDeviceFeatures2KHR*>(static_cast<void*>(p));
817 s->features.pipelineStatisticsQuery = VK_TRUE;
818 } break;
819 default: break;
820 }
821 },
__anon3431b7521602() 822 [](VkBaseOutStructure* p) -> bool { (void)p;
823 bool ret = true;
824 switch (p->sType) {
825 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: {
826 VkPhysicalDeviceFeatures2KHR* s = static_cast<VkPhysicalDeviceFeatures2KHR*>(static_cast<void*>(p));
827 ret = ret && (s->features.pipelineStatisticsQuery == VK_TRUE);
828 } break;
829 default: break;
830 }
831 return ret;
832 }
833 };
834
835 static const VpPropertyDesc propertyDesc = {
__anon3431b7521702() 836 [](VkBaseOutStructure* p) { (void)p;
837 },
__anon3431b7521802() 838 [](VkBaseOutStructure* p) -> bool { (void)p;
839 bool ret = true;
840 return ret;
841 }
842 };
843
844 static const VpStructChainerDesc chainerDesc = {
__anon3431b7521902() 845 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
846 VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, nullptr };
847 VkPhysicalDeviceCustomBorderColorFeaturesEXT physicalDeviceCustomBorderColorFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, &physicalDeviceVulkan12Features };
848 VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT physicalDevicePrimitiveTopologyListRestartFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT, &physicalDeviceCustomBorderColorFeaturesEXT };
849 VkPhysicalDeviceProvokingVertexFeaturesEXT physicalDeviceProvokingVertexFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT, &physicalDevicePrimitiveTopologyListRestartFeaturesEXT };
850 VkPhysicalDeviceIndexTypeUint8FeaturesEXT physicalDeviceIndexTypeUint8FeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, &physicalDeviceProvokingVertexFeaturesEXT };
851 VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR physicalDeviceVertexAttributeDivisorFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR, &physicalDeviceIndexTypeUint8FeaturesEXT };
852 VkPhysicalDeviceSamplerYcbcrConversionFeatures physicalDeviceSamplerYcbcrConversionFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, &physicalDeviceVertexAttributeDivisorFeaturesKHR };
853 VkPhysicalDeviceShaderFloat16Int8Features physicalDeviceShaderFloat16Int8Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, &physicalDeviceSamplerYcbcrConversionFeatures };
854 VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures physicalDeviceShaderSubgroupExtendedTypesFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, &physicalDeviceShaderFloat16Int8Features };
855 VkPhysicalDevice8BitStorageFeatures physicalDevice8BitStorageFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, &physicalDeviceShaderSubgroupExtendedTypesFeatures };
856 VkPhysicalDevice16BitStorageFeatures physicalDevice16BitStorageFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, &physicalDevice8BitStorageFeatures };
857 VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT physicalDevicePrimitivesGeneratedQueryFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT, &physicalDevice16BitStorageFeatures };
858 VkPhysicalDeviceLineRasterizationFeaturesEXT physicalDeviceLineRasterizationFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, &physicalDevicePrimitivesGeneratedQueryFeaturesEXT };
859 VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG physicalDeviceRelaxedLineRasterizationFeaturesIMG{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG, &physicalDeviceLineRasterizationFeaturesEXT };
860 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(&physicalDeviceRelaxedLineRasterizationFeaturesIMG));
861 pfnCb(p, pUser);
862 },
__anon3431b7521a02() 863 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
864 VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr };
865 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(&physicalDeviceVulkan11Properties));
866 pfnCb(p, pUser);
867 },
__anon3431b7521b02() 868 [](uint32_t count, VkBaseOutStructure* p, void* pUser, PFN_vpStructArrayChainerCb pfnCb) {
869 pfnCb(count, p, pUser);
870 },
__anon3431b7521c02() 871 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
872 VkFormatProperties3KHR formatProperties3KHR{ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr };
873 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(&formatProperties3KHR));
874 pfnCb(p, pUser);
875 },
876 };
877 } // namespace pipelineStatisticsQuery
878 namespace swBresenhamLines {
879
880 static const VkExtensionProperties deviceExtensions[] = {
881 VkExtensionProperties{ VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME, 1 },
882 };
883
884 static const VpFeatureDesc featureDesc = {
__anon3431b7521d02() 885 [](VkBaseOutStructure* p) { (void)p;
886 switch (p->sType) {
887 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: {
888 VkPhysicalDeviceLineRasterizationFeaturesEXT* s = static_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>(static_cast<void*>(p));
889 s->bresenhamLines = VK_TRUE;
890 } break;
891 default: break;
892 }
893 },
__anon3431b7521e02() 894 [](VkBaseOutStructure* p) -> bool { (void)p;
895 bool ret = true;
896 switch (p->sType) {
897 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: {
898 VkPhysicalDeviceLineRasterizationFeaturesEXT* s = static_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>(static_cast<void*>(p));
899 ret = ret && (s->bresenhamLines == VK_TRUE);
900 } break;
901 default: break;
902 }
903 return ret;
904 }
905 };
906
907 static const VpPropertyDesc propertyDesc = {
__anon3431b7521f02() 908 [](VkBaseOutStructure* p) { (void)p;
909 },
__anon3431b7522002() 910 [](VkBaseOutStructure* p) -> bool { (void)p;
911 bool ret = true;
912 return ret;
913 }
914 };
915
916 static const VpStructChainerDesc chainerDesc = {
__anon3431b7522102() 917 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
918 VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, nullptr };
919 VkPhysicalDeviceCustomBorderColorFeaturesEXT physicalDeviceCustomBorderColorFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, &physicalDeviceVulkan12Features };
920 VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT physicalDevicePrimitiveTopologyListRestartFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT, &physicalDeviceCustomBorderColorFeaturesEXT };
921 VkPhysicalDeviceProvokingVertexFeaturesEXT physicalDeviceProvokingVertexFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT, &physicalDevicePrimitiveTopologyListRestartFeaturesEXT };
922 VkPhysicalDeviceIndexTypeUint8FeaturesEXT physicalDeviceIndexTypeUint8FeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, &physicalDeviceProvokingVertexFeaturesEXT };
923 VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR physicalDeviceVertexAttributeDivisorFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR, &physicalDeviceIndexTypeUint8FeaturesEXT };
924 VkPhysicalDeviceSamplerYcbcrConversionFeatures physicalDeviceSamplerYcbcrConversionFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, &physicalDeviceVertexAttributeDivisorFeaturesKHR };
925 VkPhysicalDeviceShaderFloat16Int8Features physicalDeviceShaderFloat16Int8Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, &physicalDeviceSamplerYcbcrConversionFeatures };
926 VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures physicalDeviceShaderSubgroupExtendedTypesFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, &physicalDeviceShaderFloat16Int8Features };
927 VkPhysicalDevice8BitStorageFeatures physicalDevice8BitStorageFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, &physicalDeviceShaderSubgroupExtendedTypesFeatures };
928 VkPhysicalDevice16BitStorageFeatures physicalDevice16BitStorageFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, &physicalDevice8BitStorageFeatures };
929 VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT physicalDevicePrimitivesGeneratedQueryFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT, &physicalDevice16BitStorageFeatures };
930 VkPhysicalDeviceLineRasterizationFeaturesEXT physicalDeviceLineRasterizationFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, &physicalDevicePrimitivesGeneratedQueryFeaturesEXT };
931 VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG physicalDeviceRelaxedLineRasterizationFeaturesIMG{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG, &physicalDeviceLineRasterizationFeaturesEXT };
932 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(&physicalDeviceRelaxedLineRasterizationFeaturesIMG));
933 pfnCb(p, pUser);
934 },
__anon3431b7522202() 935 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
936 VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr };
937 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(&physicalDeviceVulkan11Properties));
938 pfnCb(p, pUser);
939 },
__anon3431b7522302() 940 [](uint32_t count, VkBaseOutStructure* p, void* pUser, PFN_vpStructArrayChainerCb pfnCb) {
941 pfnCb(count, p, pUser);
942 },
__anon3431b7522402() 943 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
944 VkFormatProperties3KHR formatProperties3KHR{ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr };
945 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(&formatProperties3KHR));
946 pfnCb(p, pUser);
947 },
948 };
949 } // namespace swBresenhamLines
950 namespace hwBresenhamLines {
951
952 static const VkExtensionProperties deviceExtensions[] = {
953 VkExtensionProperties{ VK_IMG_RELAXED_LINE_RASTERIZATION_EXTENSION_NAME, 1 },
954 };
955
956 static const VpFeatureDesc featureDesc = {
__anon3431b7522502() 957 [](VkBaseOutStructure* p) { (void)p;
958 switch (p->sType) {
959 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: {
960 VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* s = static_cast<VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG*>(static_cast<void*>(p));
961 s->relaxedLineRasterization = VK_TRUE;
962 } break;
963 default: break;
964 }
965 },
__anon3431b7522602() 966 [](VkBaseOutStructure* p) -> bool { (void)p;
967 bool ret = true;
968 switch (p->sType) {
969 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: {
970 VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* s = static_cast<VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG*>(static_cast<void*>(p));
971 ret = ret && (s->relaxedLineRasterization == VK_TRUE);
972 } break;
973 default: break;
974 }
975 return ret;
976 }
977 };
978
979 static const VpPropertyDesc propertyDesc = {
__anon3431b7522702() 980 [](VkBaseOutStructure* p) { (void)p;
981 },
__anon3431b7522802() 982 [](VkBaseOutStructure* p) -> bool { (void)p;
983 bool ret = true;
984 return ret;
985 }
986 };
987
988 static const VpStructChainerDesc chainerDesc = {
__anon3431b7522902() 989 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
990 VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, nullptr };
991 VkPhysicalDeviceCustomBorderColorFeaturesEXT physicalDeviceCustomBorderColorFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, &physicalDeviceVulkan12Features };
992 VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT physicalDevicePrimitiveTopologyListRestartFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT, &physicalDeviceCustomBorderColorFeaturesEXT };
993 VkPhysicalDeviceProvokingVertexFeaturesEXT physicalDeviceProvokingVertexFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT, &physicalDevicePrimitiveTopologyListRestartFeaturesEXT };
994 VkPhysicalDeviceIndexTypeUint8FeaturesEXT physicalDeviceIndexTypeUint8FeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, &physicalDeviceProvokingVertexFeaturesEXT };
995 VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR physicalDeviceVertexAttributeDivisorFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR, &physicalDeviceIndexTypeUint8FeaturesEXT };
996 VkPhysicalDeviceSamplerYcbcrConversionFeatures physicalDeviceSamplerYcbcrConversionFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, &physicalDeviceVertexAttributeDivisorFeaturesKHR };
997 VkPhysicalDeviceShaderFloat16Int8Features physicalDeviceShaderFloat16Int8Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, &physicalDeviceSamplerYcbcrConversionFeatures };
998 VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures physicalDeviceShaderSubgroupExtendedTypesFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, &physicalDeviceShaderFloat16Int8Features };
999 VkPhysicalDevice8BitStorageFeatures physicalDevice8BitStorageFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, &physicalDeviceShaderSubgroupExtendedTypesFeatures };
1000 VkPhysicalDevice16BitStorageFeatures physicalDevice16BitStorageFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, &physicalDevice8BitStorageFeatures };
1001 VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT physicalDevicePrimitivesGeneratedQueryFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT, &physicalDevice16BitStorageFeatures };
1002 VkPhysicalDeviceLineRasterizationFeaturesEXT physicalDeviceLineRasterizationFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, &physicalDevicePrimitivesGeneratedQueryFeaturesEXT };
1003 VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG physicalDeviceRelaxedLineRasterizationFeaturesIMG{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG, &physicalDeviceLineRasterizationFeaturesEXT };
1004 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(&physicalDeviceRelaxedLineRasterizationFeaturesIMG));
1005 pfnCb(p, pUser);
1006 },
__anon3431b7522a02() 1007 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
1008 VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, nullptr };
1009 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(&physicalDeviceVulkan11Properties));
1010 pfnCb(p, pUser);
1011 },
__anon3431b7522b02() 1012 [](uint32_t count, VkBaseOutStructure* p, void* pUser, PFN_vpStructArrayChainerCb pfnCb) {
1013 pfnCb(count, p, pUser);
1014 },
__anon3431b7522c02() 1015 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
1016 VkFormatProperties3KHR formatProperties3KHR{ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr };
1017 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(&formatProperties3KHR));
1018 pfnCb(p, pUser);
1019 },
1020 };
1021 } // namespace hwBresenhamLines
1022 } // namespace blocks
1023 } // namespace VP_ANDROID_15_MINIMUMS
1024 #endif // VP_ANDROID_15_minimums
1025
1026 #ifdef VP_ANDROID_16_minimums
1027 namespace VP_ANDROID_16_MINIMUMS {
1028
1029 static const VkStructureType featureStructTypes[] = {
1030 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR,
1031 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES,
1032 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES,
1033 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES,
1034 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT,
1035 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT,
1036 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR,
1037 };
1038
1039 static const VkStructureType propertyStructTypes[] = {
1040 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR,
1041 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES,
1042 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES,
1043 };
1044
1045 namespace blocks {
1046 namespace MUST {
1047
1048 static const VkExtensionProperties deviceExtensions[] = {
1049 VkExtensionProperties{ VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME, 1 },
1050 VkExtensionProperties{ VK_EXT_IMAGE_2D_VIEW_OF_3D_EXTENSION_NAME, 1 },
1051 VkExtensionProperties{ VK_EXT_PIPELINE_PROTECTED_ACCESS_EXTENSION_NAME, 1 },
1052 VkExtensionProperties{ VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME, 1 },
1053 VkExtensionProperties{ VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME, 1 },
1054 VkExtensionProperties{ VK_KHR_8BIT_STORAGE_EXTENSION_NAME, 1 },
1055 VkExtensionProperties{ VK_KHR_LOAD_STORE_OP_NONE_EXTENSION_NAME, 1 },
1056 VkExtensionProperties{ VK_KHR_MAINTENANCE_6_EXTENSION_NAME, 1 },
1057 VkExtensionProperties{ VK_KHR_MAP_MEMORY_2_EXTENSION_NAME, 1 },
1058 VkExtensionProperties{ VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME, 1 },
1059 VkExtensionProperties{ VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME, 1 },
1060 VkExtensionProperties{ VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_EXTENSION_NAME, 1 },
1061 VkExtensionProperties{ VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME, 1 },
1062 VkExtensionProperties{ VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME, 1 },
1063 VkExtensionProperties{ VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME, 1 },
1064 };
1065
1066 static const VpFeatureDesc featureDesc = {
__anon3431b7522d02() 1067 [](VkBaseOutStructure* p) { (void)p;
1068 switch (p->sType) {
1069 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: {
1070 VkPhysicalDeviceFeatures2KHR* s = static_cast<VkPhysicalDeviceFeatures2KHR*>(static_cast<void*>(p));
1071 s->features.fullDrawIndexUint32 = VK_TRUE;
1072 s->features.shaderInt16 = VK_TRUE;
1073 } break;
1074 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: {
1075 VkPhysicalDeviceVulkan12Features* s = static_cast<VkPhysicalDeviceVulkan12Features*>(static_cast<void*>(p));
1076 s->samplerMirrorClampToEdge = VK_TRUE;
1077 s->scalarBlockLayout = VK_TRUE;
1078 } break;
1079 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: {
1080 VkPhysicalDeviceProtectedMemoryFeatures* s = static_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(static_cast<void*>(p));
1081 s->protectedMemory = VK_TRUE;
1082 } break;
1083 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: {
1084 VkPhysicalDeviceShaderIntegerDotProductFeatures* s = static_cast<VkPhysicalDeviceShaderIntegerDotProductFeatures*>(static_cast<void*>(p));
1085 s->shaderIntegerDotProduct = VK_TRUE;
1086 } break;
1087 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: {
1088 VkPhysicalDeviceTransformFeedbackFeaturesEXT* s = static_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(static_cast<void*>(p));
1089 s->transformFeedback = VK_TRUE;
1090 } break;
1091 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: {
1092 VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* s = static_cast<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*>(static_cast<void*>(p));
1093 s->image2DViewOf3D = VK_TRUE;
1094 } break;
1095 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: {
1096 VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* s = static_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(static_cast<void*>(p));
1097 s->shaderSubgroupUniformControlFlow = VK_TRUE;
1098 } break;
1099 default: break;
1100 }
1101 },
__anon3431b7522e02() 1102 [](VkBaseOutStructure* p) -> bool { (void)p;
1103 bool ret = true;
1104 switch (p->sType) {
1105 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: {
1106 VkPhysicalDeviceFeatures2KHR* s = static_cast<VkPhysicalDeviceFeatures2KHR*>(static_cast<void*>(p));
1107 ret = ret && (s->features.fullDrawIndexUint32 == VK_TRUE);
1108 ret = ret && (s->features.shaderInt16 == VK_TRUE);
1109 } break;
1110 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: {
1111 VkPhysicalDeviceVulkan12Features* s = static_cast<VkPhysicalDeviceVulkan12Features*>(static_cast<void*>(p));
1112 ret = ret && (s->samplerMirrorClampToEdge == VK_TRUE);
1113 ret = ret && (s->scalarBlockLayout == VK_TRUE);
1114 } break;
1115 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: {
1116 VkPhysicalDeviceProtectedMemoryFeatures* s = static_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(static_cast<void*>(p));
1117 ret = ret && (s->protectedMemory == VK_TRUE);
1118 } break;
1119 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: {
1120 VkPhysicalDeviceShaderIntegerDotProductFeatures* s = static_cast<VkPhysicalDeviceShaderIntegerDotProductFeatures*>(static_cast<void*>(p));
1121 ret = ret && (s->shaderIntegerDotProduct == VK_TRUE);
1122 } break;
1123 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: {
1124 VkPhysicalDeviceTransformFeedbackFeaturesEXT* s = static_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(static_cast<void*>(p));
1125 ret = ret && (s->transformFeedback == VK_TRUE);
1126 } break;
1127 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: {
1128 VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* s = static_cast<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*>(static_cast<void*>(p));
1129 ret = ret && (s->image2DViewOf3D == VK_TRUE);
1130 } break;
1131 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: {
1132 VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* s = static_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(static_cast<void*>(p));
1133 ret = ret && (s->shaderSubgroupUniformControlFlow == VK_TRUE);
1134 } break;
1135 default: break;
1136 }
1137 return ret;
1138 }
1139 };
1140
1141 static const VpPropertyDesc propertyDesc = {
__anon3431b7522f02() 1142 [](VkBaseOutStructure* p) { (void)p;
1143 switch (p->sType) {
1144 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: {
1145 VkPhysicalDeviceProperties2KHR* s = static_cast<VkPhysicalDeviceProperties2KHR*>(static_cast<void*>(p));
1146 s->properties.limits.bufferImageGranularity = 4096;
1147 s->properties.limits.lineWidthGranularity = 0.5f;
1148 s->properties.limits.maxColorAttachments = 8;
1149 s->properties.limits.maxComputeWorkGroupInvocations = 256;
1150 s->properties.limits.maxComputeWorkGroupSize[0] = 256;
1151 s->properties.limits.maxComputeWorkGroupSize[1] = 256;
1152 s->properties.limits.maxComputeWorkGroupSize[2] = 64;
1153 s->properties.limits.maxDescriptorSetStorageBuffers = 96;
1154 s->properties.limits.maxDescriptorSetUniformBuffers = 90;
1155 s->properties.limits.maxFragmentCombinedOutputResources = 16;
1156 s->properties.limits.maxImageArrayLayers = 2048;
1157 s->properties.limits.maxImageDimension1D = 8192;
1158 s->properties.limits.maxImageDimension2D = 8192;
1159 s->properties.limits.maxImageDimensionCube = 8192;
1160 s->properties.limits.maxPerStageDescriptorUniformBuffers = 15;
1161 s->properties.limits.maxPerStageResources = 200;
1162 s->properties.limits.maxSamplerLodBias = 14;
1163 s->properties.limits.maxUniformBufferRange = 65536;
1164 s->properties.limits.maxVertexOutputComponents = 72;
1165 s->properties.limits.mipmapPrecisionBits = 6;
1166 s->properties.limits.pointSizeGranularity = 0.125f;
1167 s->properties.limits.standardSampleLocations = VK_TRUE;
1168 s->properties.limits.subTexelPrecisionBits = 8;
1169 s->properties.limits.timestampComputeAndGraphics = VK_TRUE;
1170 } break;
1171 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: {
1172 VkPhysicalDeviceFloatControlsProperties* s = static_cast<VkPhysicalDeviceFloatControlsProperties*>(static_cast<void*>(p));
1173 s->shaderSignedZeroInfNanPreserveFloat16 = VK_TRUE;
1174 s->shaderSignedZeroInfNanPreserveFloat32 = VK_TRUE;
1175 } break;
1176 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: {
1177 VkPhysicalDeviceVulkan11Properties* s = static_cast<VkPhysicalDeviceVulkan11Properties*>(static_cast<void*>(p));
1178 s->subgroupSupportedStages |= (VK_SHADER_STAGE_COMPUTE_BIT);
1179 } break;
1180 default: break;
1181 }
1182 },
__anon3431b7523002() 1183 [](VkBaseOutStructure* p) -> bool { (void)p;
1184 bool ret = true;
1185 switch (p->sType) {
1186 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: {
1187 VkPhysicalDeviceProperties2KHR* s = static_cast<VkPhysicalDeviceProperties2KHR*>(static_cast<void*>(p));
1188 ret = ret && (s->properties.limits.bufferImageGranularity <= 4096);
1189 ret = ret && ((4096 % s->properties.limits.bufferImageGranularity) == 0);
1190 ret = ret && (s->properties.limits.lineWidthGranularity <= 0.5);
1191 ret = ret && (isMultiple(0.5, s->properties.limits.lineWidthGranularity));
1192 ret = ret && (s->properties.limits.maxColorAttachments >= 8);
1193 ret = ret && (s->properties.limits.maxComputeWorkGroupInvocations >= 256);
1194 ret = ret && (s->properties.limits.maxComputeWorkGroupSize[0] >= 256);
1195 ret = ret && (s->properties.limits.maxComputeWorkGroupSize[1] >= 256);
1196 ret = ret && (s->properties.limits.maxComputeWorkGroupSize[2] >= 64);
1197 ret = ret && (s->properties.limits.maxDescriptorSetStorageBuffers >= 96);
1198 ret = ret && (s->properties.limits.maxDescriptorSetUniformBuffers >= 90);
1199 ret = ret && (s->properties.limits.maxFragmentCombinedOutputResources >= 16);
1200 ret = ret && (s->properties.limits.maxImageArrayLayers >= 2048);
1201 ret = ret && (s->properties.limits.maxImageDimension1D >= 8192);
1202 ret = ret && (s->properties.limits.maxImageDimension2D >= 8192);
1203 ret = ret && (s->properties.limits.maxImageDimensionCube >= 8192);
1204 ret = ret && (s->properties.limits.maxPerStageDescriptorUniformBuffers >= 15);
1205 ret = ret && (s->properties.limits.maxPerStageResources >= 200);
1206 ret = ret && (s->properties.limits.maxSamplerLodBias >= 14);
1207 ret = ret && (s->properties.limits.maxUniformBufferRange >= 65536);
1208 ret = ret && (s->properties.limits.maxVertexOutputComponents >= 72);
1209 ret = ret && (s->properties.limits.mipmapPrecisionBits >= 6);
1210 ret = ret && (s->properties.limits.pointSizeGranularity <= 0.125);
1211 ret = ret && (isMultiple(0.125, s->properties.limits.pointSizeGranularity));
1212 ret = ret && (s->properties.limits.standardSampleLocations == VK_TRUE);
1213 ret = ret && (s->properties.limits.subTexelPrecisionBits >= 8);
1214 ret = ret && (vpCheckFlags(s->properties.limits.timestampComputeAndGraphics, VK_TRUE));
1215 } break;
1216 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: {
1217 VkPhysicalDeviceFloatControlsProperties* s = static_cast<VkPhysicalDeviceFloatControlsProperties*>(static_cast<void*>(p));
1218 ret = ret && (vpCheckFlags(s->shaderSignedZeroInfNanPreserveFloat16, VK_TRUE));
1219 ret = ret && (vpCheckFlags(s->shaderSignedZeroInfNanPreserveFloat32, VK_TRUE));
1220 } break;
1221 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: {
1222 VkPhysicalDeviceVulkan11Properties* s = static_cast<VkPhysicalDeviceVulkan11Properties*>(static_cast<void*>(p));
1223 ret = ret && (vpCheckFlags(s->subgroupSupportedStages, (VK_SHADER_STAGE_COMPUTE_BIT)));
1224 } break;
1225 default: break;
1226 }
1227 return ret;
1228 }
1229 };
1230
1231 static const VpStructChainerDesc chainerDesc = {
__anon3431b7523102() 1232 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
1233 VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, nullptr };
1234 VkPhysicalDeviceProtectedMemoryFeatures physicalDeviceProtectedMemoryFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, &physicalDeviceVulkan12Features };
1235 VkPhysicalDeviceShaderIntegerDotProductFeatures physicalDeviceShaderIntegerDotProductFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, &physicalDeviceProtectedMemoryFeatures };
1236 VkPhysicalDeviceTransformFeedbackFeaturesEXT physicalDeviceTransformFeedbackFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, &physicalDeviceShaderIntegerDotProductFeatures };
1237 VkPhysicalDeviceImage2DViewOf3DFeaturesEXT physicalDeviceImage2DViewOf3DFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT, &physicalDeviceTransformFeedbackFeaturesEXT };
1238 VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR, &physicalDeviceImage2DViewOf3DFeaturesEXT };
1239 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(&physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR));
1240 pfnCb(p, pUser);
1241 },
__anon3431b7523202() 1242 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
1243 VkPhysicalDeviceFloatControlsProperties physicalDeviceFloatControlsProperties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, nullptr };
1244 VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, &physicalDeviceFloatControlsProperties };
1245 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(&physicalDeviceVulkan11Properties));
1246 pfnCb(p, pUser);
1247 },
__anon3431b7523302() 1248 [](uint32_t count, VkBaseOutStructure* p, void* pUser, PFN_vpStructArrayChainerCb pfnCb) {
1249 pfnCb(count, p, pUser);
1250 },
__anon3431b7523402() 1251 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
1252 pfnCb(p, pUser);
1253 },
1254 };
1255 } // namespace MUST
1256 namespace multisampledToSingleSampled {
1257
1258 static const VkExtensionProperties deviceExtensions[] = {
1259 VkExtensionProperties{ VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXTENSION_NAME, 1 },
1260 };
1261
1262 static const VpFeatureDesc featureDesc = {
__anon3431b7523502() 1263 [](VkBaseOutStructure* p) { (void)p;
1264 },
__anon3431b7523602() 1265 [](VkBaseOutStructure* p) -> bool { (void)p;
1266 bool ret = true;
1267 return ret;
1268 }
1269 };
1270
1271 static const VpPropertyDesc propertyDesc = {
__anon3431b7523702() 1272 [](VkBaseOutStructure* p) { (void)p;
1273 },
__anon3431b7523802() 1274 [](VkBaseOutStructure* p) -> bool { (void)p;
1275 bool ret = true;
1276 return ret;
1277 }
1278 };
1279
1280 static const VpStructChainerDesc chainerDesc = {
__anon3431b7523902() 1281 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
1282 VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, nullptr };
1283 VkPhysicalDeviceProtectedMemoryFeatures physicalDeviceProtectedMemoryFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, &physicalDeviceVulkan12Features };
1284 VkPhysicalDeviceShaderIntegerDotProductFeatures physicalDeviceShaderIntegerDotProductFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, &physicalDeviceProtectedMemoryFeatures };
1285 VkPhysicalDeviceTransformFeedbackFeaturesEXT physicalDeviceTransformFeedbackFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, &physicalDeviceShaderIntegerDotProductFeatures };
1286 VkPhysicalDeviceImage2DViewOf3DFeaturesEXT physicalDeviceImage2DViewOf3DFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT, &physicalDeviceTransformFeedbackFeaturesEXT };
1287 VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR, &physicalDeviceImage2DViewOf3DFeaturesEXT };
1288 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(&physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR));
1289 pfnCb(p, pUser);
1290 },
__anon3431b7523a02() 1291 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
1292 VkPhysicalDeviceFloatControlsProperties physicalDeviceFloatControlsProperties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, nullptr };
1293 VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, &physicalDeviceFloatControlsProperties };
1294 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(&physicalDeviceVulkan11Properties));
1295 pfnCb(p, pUser);
1296 },
__anon3431b7523b02() 1297 [](uint32_t count, VkBaseOutStructure* p, void* pUser, PFN_vpStructArrayChainerCb pfnCb) {
1298 pfnCb(count, p, pUser);
1299 },
__anon3431b7523c02() 1300 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
1301 pfnCb(p, pUser);
1302 },
1303 };
1304 } // namespace multisampledToSingleSampled
1305 namespace shaderStencilExport {
1306
1307 static const VkExtensionProperties deviceExtensions[] = {
1308 VkExtensionProperties{ VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME, 1 },
1309 };
1310
1311 static const VpFeatureDesc featureDesc = {
__anon3431b7523d02() 1312 [](VkBaseOutStructure* p) { (void)p;
1313 },
__anon3431b7523e02() 1314 [](VkBaseOutStructure* p) -> bool { (void)p;
1315 bool ret = true;
1316 return ret;
1317 }
1318 };
1319
1320 static const VpPropertyDesc propertyDesc = {
__anon3431b7523f02() 1321 [](VkBaseOutStructure* p) { (void)p;
1322 },
__anon3431b7524002() 1323 [](VkBaseOutStructure* p) -> bool { (void)p;
1324 bool ret = true;
1325 return ret;
1326 }
1327 };
1328
1329 static const VpStructChainerDesc chainerDesc = {
__anon3431b7524102() 1330 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
1331 VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, nullptr };
1332 VkPhysicalDeviceProtectedMemoryFeatures physicalDeviceProtectedMemoryFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, &physicalDeviceVulkan12Features };
1333 VkPhysicalDeviceShaderIntegerDotProductFeatures physicalDeviceShaderIntegerDotProductFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, &physicalDeviceProtectedMemoryFeatures };
1334 VkPhysicalDeviceTransformFeedbackFeaturesEXT physicalDeviceTransformFeedbackFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, &physicalDeviceShaderIntegerDotProductFeatures };
1335 VkPhysicalDeviceImage2DViewOf3DFeaturesEXT physicalDeviceImage2DViewOf3DFeaturesEXT{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT, &physicalDeviceTransformFeedbackFeaturesEXT };
1336 VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR, &physicalDeviceImage2DViewOf3DFeaturesEXT };
1337 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(&physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR));
1338 pfnCb(p, pUser);
1339 },
__anon3431b7524202() 1340 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
1341 VkPhysicalDeviceFloatControlsProperties physicalDeviceFloatControlsProperties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, nullptr };
1342 VkPhysicalDeviceVulkan11Properties physicalDeviceVulkan11Properties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, &physicalDeviceFloatControlsProperties };
1343 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(&physicalDeviceVulkan11Properties));
1344 pfnCb(p, pUser);
1345 },
__anon3431b7524302() 1346 [](uint32_t count, VkBaseOutStructure* p, void* pUser, PFN_vpStructArrayChainerCb pfnCb) {
1347 pfnCb(count, p, pUser);
1348 },
__anon3431b7524402() 1349 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
1350 pfnCb(p, pUser);
1351 },
1352 };
1353 } // namespace shaderStencilExport
1354 } // namespace blocks
1355 } // namespace VP_ANDROID_16_MINIMUMS
1356 #endif // VP_ANDROID_16_minimums
1357
1358 #ifdef VP_ANDROID_baseline_2021
1359 namespace VP_ANDROID_BASELINE_2021 {
1360
1361 static const VkStructureType featureStructTypes[] = {
1362 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR,
1363 };
1364
1365 static const VkStructureType propertyStructTypes[] = {
1366 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR,
1367 };
1368
1369 static const VkStructureType formatStructTypes[] = {
1370 VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR,
1371 VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR,
1372 };
1373
1374 static const VkExtensionProperties instanceExtensions[] = {
1375 VkExtensionProperties{ VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME, 1 },
1376 VkExtensionProperties{ VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, 1 },
1377 VkExtensionProperties{ VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME, 1 },
1378 VkExtensionProperties{ VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, 1 },
1379 VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME, 1 },
1380 VkExtensionProperties{ VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, 1 },
1381 VkExtensionProperties{ VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, 1 },
1382 VkExtensionProperties{ VK_KHR_SURFACE_EXTENSION_NAME, 1 },
1383 };
1384
1385 static const VkExtensionProperties deviceExtensions[] = {
1386 VkExtensionProperties{ VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME, 1 },
1387 VkExtensionProperties{ VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, 1 },
1388 VkExtensionProperties{ VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME, 1 },
1389 VkExtensionProperties{ VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME, 1 },
1390 VkExtensionProperties{ VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME, 1 },
1391 VkExtensionProperties{ VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, 1 },
1392 VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME, 1 },
1393 VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME, 1 },
1394 VkExtensionProperties{ VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, 1 },
1395 VkExtensionProperties{ VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME, 1 },
1396 VkExtensionProperties{ VK_KHR_MAINTENANCE_1_EXTENSION_NAME, 1 },
1397 VkExtensionProperties{ VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME, 1 },
1398 VkExtensionProperties{ VK_KHR_SWAPCHAIN_EXTENSION_NAME, 1 },
1399 VkExtensionProperties{ VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME, 1 },
1400 };
1401
1402 static const VpFeatureDesc featureDesc = {
__anon3431b7524502() 1403 [](VkBaseOutStructure* p) { (void)p;
1404 switch (p->sType) {
1405 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: {
1406 VkPhysicalDeviceFeatures2KHR* s = static_cast<VkPhysicalDeviceFeatures2KHR*>(static_cast<void*>(p));
1407 s->features.depthBiasClamp = VK_TRUE;
1408 s->features.fragmentStoresAndAtomics = VK_TRUE;
1409 s->features.fullDrawIndexUint32 = VK_TRUE;
1410 s->features.imageCubeArray = VK_TRUE;
1411 s->features.independentBlend = VK_TRUE;
1412 s->features.robustBufferAccess = VK_TRUE;
1413 s->features.sampleRateShading = VK_TRUE;
1414 s->features.shaderSampledImageArrayDynamicIndexing = VK_TRUE;
1415 s->features.shaderStorageImageArrayDynamicIndexing = VK_TRUE;
1416 s->features.shaderUniformBufferArrayDynamicIndexing = VK_TRUE;
1417 s->features.textureCompressionASTC_LDR = VK_TRUE;
1418 s->features.textureCompressionETC2 = VK_TRUE;
1419 } break;
1420 default: break;
1421 }
1422 },
__anon3431b7524602() 1423 [](VkBaseOutStructure* p) -> bool { (void)p;
1424 bool ret = true;
1425 switch (p->sType) {
1426 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: {
1427 VkPhysicalDeviceFeatures2KHR* s = static_cast<VkPhysicalDeviceFeatures2KHR*>(static_cast<void*>(p));
1428 ret = ret && (s->features.depthBiasClamp == VK_TRUE);
1429 ret = ret && (s->features.fragmentStoresAndAtomics == VK_TRUE);
1430 ret = ret && (s->features.fullDrawIndexUint32 == VK_TRUE);
1431 ret = ret && (s->features.imageCubeArray == VK_TRUE);
1432 ret = ret && (s->features.independentBlend == VK_TRUE);
1433 ret = ret && (s->features.robustBufferAccess == VK_TRUE);
1434 ret = ret && (s->features.sampleRateShading == VK_TRUE);
1435 ret = ret && (s->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE);
1436 ret = ret && (s->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE);
1437 ret = ret && (s->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE);
1438 ret = ret && (s->features.textureCompressionASTC_LDR == VK_TRUE);
1439 ret = ret && (s->features.textureCompressionETC2 == VK_TRUE);
1440 } break;
1441 default: break;
1442 }
1443 return ret;
1444 }
1445 };
1446
1447 static const VpPropertyDesc propertyDesc = {
__anon3431b7524702() 1448 [](VkBaseOutStructure* p) { (void)p;
1449 },
__anon3431b7524802() 1450 [](VkBaseOutStructure* p) -> bool { (void)p;
1451 bool ret = true;
1452 return ret;
1453 }
1454 };
1455
1456 static const VpStructChainerDesc chainerDesc = {
__anon3431b7524902() 1457 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
1458 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(nullptr));
1459 pfnCb(p, pUser);
1460 },
__anon3431b7524a02() 1461 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
1462 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(nullptr));
1463 pfnCb(p, pUser);
1464 },
__anon3431b7524b02() 1465 [](uint32_t count, VkBaseOutStructure* p, void* pUser, PFN_vpStructArrayChainerCb pfnCb) {
1466 pfnCb(count, p, pUser);
1467 },
__anon3431b7524c02() 1468 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
1469 VkFormatProperties3KHR formatProperties3KHR{ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr };
1470 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(&formatProperties3KHR));
1471 pfnCb(p, pUser);
1472 },
1473 };
1474
1475 namespace blocks {
1476 namespace baseline {
1477
1478 static const VkExtensionProperties instanceExtensions[] = {
1479 VkExtensionProperties{ VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME, 1 },
1480 VkExtensionProperties{ VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, 1 },
1481 VkExtensionProperties{ VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME, 1 },
1482 VkExtensionProperties{ VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, 1 },
1483 VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME, 1 },
1484 VkExtensionProperties{ VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, 1 },
1485 VkExtensionProperties{ VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, 1 },
1486 VkExtensionProperties{ VK_KHR_SURFACE_EXTENSION_NAME, 1 },
1487 };
1488
1489 static const VkExtensionProperties deviceExtensions[] = {
1490 VkExtensionProperties{ VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME, 1 },
1491 VkExtensionProperties{ VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, 1 },
1492 VkExtensionProperties{ VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME, 1 },
1493 VkExtensionProperties{ VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME, 1 },
1494 VkExtensionProperties{ VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME, 1 },
1495 VkExtensionProperties{ VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, 1 },
1496 VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME, 1 },
1497 VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME, 1 },
1498 VkExtensionProperties{ VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, 1 },
1499 VkExtensionProperties{ VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME, 1 },
1500 VkExtensionProperties{ VK_KHR_MAINTENANCE_1_EXTENSION_NAME, 1 },
1501 VkExtensionProperties{ VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME, 1 },
1502 VkExtensionProperties{ VK_KHR_SWAPCHAIN_EXTENSION_NAME, 1 },
1503 VkExtensionProperties{ VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME, 1 },
1504 };
1505
1506 static const VpFeatureDesc featureDesc = {
__anon3431b7524d02() 1507 [](VkBaseOutStructure* p) { (void)p;
1508 switch (p->sType) {
1509 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: {
1510 VkPhysicalDeviceFeatures2KHR* s = static_cast<VkPhysicalDeviceFeatures2KHR*>(static_cast<void*>(p));
1511 s->features.depthBiasClamp = VK_TRUE;
1512 s->features.fragmentStoresAndAtomics = VK_TRUE;
1513 s->features.fullDrawIndexUint32 = VK_TRUE;
1514 s->features.imageCubeArray = VK_TRUE;
1515 s->features.independentBlend = VK_TRUE;
1516 s->features.robustBufferAccess = VK_TRUE;
1517 s->features.sampleRateShading = VK_TRUE;
1518 s->features.shaderSampledImageArrayDynamicIndexing = VK_TRUE;
1519 s->features.shaderStorageImageArrayDynamicIndexing = VK_TRUE;
1520 s->features.shaderUniformBufferArrayDynamicIndexing = VK_TRUE;
1521 s->features.textureCompressionASTC_LDR = VK_TRUE;
1522 s->features.textureCompressionETC2 = VK_TRUE;
1523 } break;
1524 default: break;
1525 }
1526 },
__anon3431b7524e02() 1527 [](VkBaseOutStructure* p) -> bool { (void)p;
1528 bool ret = true;
1529 switch (p->sType) {
1530 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: {
1531 VkPhysicalDeviceFeatures2KHR* s = static_cast<VkPhysicalDeviceFeatures2KHR*>(static_cast<void*>(p));
1532 ret = ret && (s->features.depthBiasClamp == VK_TRUE);
1533 ret = ret && (s->features.fragmentStoresAndAtomics == VK_TRUE);
1534 ret = ret && (s->features.fullDrawIndexUint32 == VK_TRUE);
1535 ret = ret && (s->features.imageCubeArray == VK_TRUE);
1536 ret = ret && (s->features.independentBlend == VK_TRUE);
1537 ret = ret && (s->features.robustBufferAccess == VK_TRUE);
1538 ret = ret && (s->features.sampleRateShading == VK_TRUE);
1539 ret = ret && (s->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE);
1540 ret = ret && (s->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE);
1541 ret = ret && (s->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE);
1542 ret = ret && (s->features.textureCompressionASTC_LDR == VK_TRUE);
1543 ret = ret && (s->features.textureCompressionETC2 == VK_TRUE);
1544 } break;
1545 default: break;
1546 }
1547 return ret;
1548 }
1549 };
1550
1551 static const VpPropertyDesc propertyDesc = {
__anon3431b7524f02() 1552 [](VkBaseOutStructure* p) { (void)p;
1553 switch (p->sType) {
1554 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: {
1555 VkPhysicalDeviceProperties2KHR* s = static_cast<VkPhysicalDeviceProperties2KHR*>(static_cast<void*>(p));
1556 s->properties.limits.discreteQueuePriorities = 2;
1557 s->properties.limits.framebufferColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT);
1558 s->properties.limits.framebufferDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT);
1559 s->properties.limits.framebufferNoAttachmentsSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT);
1560 s->properties.limits.framebufferStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT);
1561 s->properties.limits.maxBoundDescriptorSets = 4;
1562 s->properties.limits.maxColorAttachments = 4;
1563 s->properties.limits.maxComputeSharedMemorySize = 16384;
1564 s->properties.limits.maxComputeWorkGroupCount[0] = 65535;
1565 s->properties.limits.maxComputeWorkGroupCount[1] = 65535;
1566 s->properties.limits.maxComputeWorkGroupCount[2] = 65535;
1567 s->properties.limits.maxComputeWorkGroupInvocations = 128;
1568 s->properties.limits.maxComputeWorkGroupSize[0] = 128;
1569 s->properties.limits.maxComputeWorkGroupSize[1] = 128;
1570 s->properties.limits.maxComputeWorkGroupSize[2] = 64;
1571 s->properties.limits.maxDescriptorSetInputAttachments = 4;
1572 s->properties.limits.maxDescriptorSetSampledImages = 48;
1573 s->properties.limits.maxDescriptorSetSamplers = 48;
1574 s->properties.limits.maxDescriptorSetStorageBuffers = 24;
1575 s->properties.limits.maxDescriptorSetStorageBuffersDynamic = 4;
1576 s->properties.limits.maxDescriptorSetStorageImages = 12;
1577 s->properties.limits.maxDescriptorSetUniformBuffers = 36;
1578 s->properties.limits.maxDescriptorSetUniformBuffersDynamic = 8;
1579 s->properties.limits.maxDrawIndexedIndexValue = 4294967295;
1580 s->properties.limits.maxDrawIndirectCount = 1;
1581 s->properties.limits.maxFragmentCombinedOutputResources = 8;
1582 s->properties.limits.maxFragmentInputComponents = 64;
1583 s->properties.limits.maxFragmentOutputAttachments = 4;
1584 s->properties.limits.maxFramebufferHeight = 4096;
1585 s->properties.limits.maxFramebufferLayers = 256;
1586 s->properties.limits.maxFramebufferWidth = 4096;
1587 s->properties.limits.maxImageArrayLayers = 256;
1588 s->properties.limits.maxImageDimension1D = 4096;
1589 s->properties.limits.maxImageDimension2D = 4096;
1590 s->properties.limits.maxImageDimension3D = 512;
1591 s->properties.limits.maxImageDimensionCube = 4096;
1592 s->properties.limits.maxInterpolationOffset = 0.4375f;
1593 s->properties.limits.maxMemoryAllocationCount = 4096;
1594 s->properties.limits.maxPerStageDescriptorInputAttachments = 4;
1595 s->properties.limits.maxPerStageDescriptorSampledImages = 16;
1596 s->properties.limits.maxPerStageDescriptorSamplers = 16;
1597 s->properties.limits.maxPerStageDescriptorStorageBuffers = 4;
1598 s->properties.limits.maxPerStageDescriptorStorageImages = 4;
1599 s->properties.limits.maxPerStageDescriptorUniformBuffers = 12;
1600 s->properties.limits.maxPerStageResources = 44;
1601 s->properties.limits.maxPushConstantsSize = 128;
1602 s->properties.limits.maxSampleMaskWords = 1;
1603 s->properties.limits.maxSamplerAllocationCount = 4000;
1604 s->properties.limits.maxSamplerAnisotropy = 1.0f;
1605 s->properties.limits.maxSamplerLodBias = 2.0f;
1606 s->properties.limits.maxStorageBufferRange = 134217728;
1607 s->properties.limits.maxTexelBufferElements = 65536;
1608 s->properties.limits.maxTexelOffset = 7;
1609 s->properties.limits.maxUniformBufferRange = 16384;
1610 s->properties.limits.maxVertexInputAttributeOffset = 2047;
1611 s->properties.limits.maxVertexInputAttributes = 16;
1612 s->properties.limits.maxVertexInputBindingStride = 2048;
1613 s->properties.limits.maxVertexInputBindings = 16;
1614 s->properties.limits.maxVertexOutputComponents = 64;
1615 s->properties.limits.maxViewportDimensions[0] = 4096;
1616 s->properties.limits.maxViewportDimensions[1] = 4096;
1617 s->properties.limits.maxViewports = 1;
1618 s->properties.limits.minInterpolationOffset = -0.5f;
1619 s->properties.limits.minMemoryMapAlignment = 4096;
1620 s->properties.limits.minStorageBufferOffsetAlignment = 256;
1621 s->properties.limits.minTexelBufferOffsetAlignment = 256;
1622 s->properties.limits.minTexelOffset = -8;
1623 s->properties.limits.minUniformBufferOffsetAlignment = 256;
1624 s->properties.limits.mipmapPrecisionBits = 4;
1625 s->properties.limits.pointSizeGranularity = 1;
1626 s->properties.limits.sampledImageColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT);
1627 s->properties.limits.sampledImageDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT);
1628 s->properties.limits.sampledImageIntegerSampleCounts |= (VK_SAMPLE_COUNT_1_BIT);
1629 s->properties.limits.sampledImageStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT);
1630 s->properties.limits.standardSampleLocations = VK_TRUE;
1631 s->properties.limits.storageImageSampleCounts |= (VK_SAMPLE_COUNT_1_BIT);
1632 s->properties.limits.subPixelInterpolationOffsetBits = 4;
1633 s->properties.limits.subPixelPrecisionBits = 4;
1634 s->properties.limits.subTexelPrecisionBits = 4;
1635 s->properties.limits.viewportBoundsRange[0] = -8192;
1636 s->properties.limits.viewportBoundsRange[1] = 8191;
1637 } break;
1638 default: break;
1639 }
1640 },
__anon3431b7525002() 1641 [](VkBaseOutStructure* p) -> bool { (void)p;
1642 bool ret = true;
1643 switch (p->sType) {
1644 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: {
1645 VkPhysicalDeviceProperties2KHR* s = static_cast<VkPhysicalDeviceProperties2KHR*>(static_cast<void*>(p));
1646 ret = ret && (s->properties.limits.discreteQueuePriorities >= 2);
1647 ret = ret && (vpCheckFlags(s->properties.limits.framebufferColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)));
1648 ret = ret && (vpCheckFlags(s->properties.limits.framebufferDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)));
1649 ret = ret && (vpCheckFlags(s->properties.limits.framebufferNoAttachmentsSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)));
1650 ret = ret && (vpCheckFlags(s->properties.limits.framebufferStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)));
1651 ret = ret && (s->properties.limits.maxBoundDescriptorSets >= 4);
1652 ret = ret && (s->properties.limits.maxColorAttachments >= 4);
1653 ret = ret && (s->properties.limits.maxComputeSharedMemorySize >= 16384);
1654 ret = ret && (s->properties.limits.maxComputeWorkGroupCount[0] >= 65535);
1655 ret = ret && (s->properties.limits.maxComputeWorkGroupCount[1] >= 65535);
1656 ret = ret && (s->properties.limits.maxComputeWorkGroupCount[2] >= 65535);
1657 ret = ret && (s->properties.limits.maxComputeWorkGroupInvocations >= 128);
1658 ret = ret && (s->properties.limits.maxComputeWorkGroupSize[0] >= 128);
1659 ret = ret && (s->properties.limits.maxComputeWorkGroupSize[1] >= 128);
1660 ret = ret && (s->properties.limits.maxComputeWorkGroupSize[2] >= 64);
1661 ret = ret && (s->properties.limits.maxDescriptorSetInputAttachments >= 4);
1662 ret = ret && (s->properties.limits.maxDescriptorSetSampledImages >= 48);
1663 ret = ret && (s->properties.limits.maxDescriptorSetSamplers >= 48);
1664 ret = ret && (s->properties.limits.maxDescriptorSetStorageBuffers >= 24);
1665 ret = ret && (s->properties.limits.maxDescriptorSetStorageBuffersDynamic >= 4);
1666 ret = ret && (s->properties.limits.maxDescriptorSetStorageImages >= 12);
1667 ret = ret && (s->properties.limits.maxDescriptorSetUniformBuffers >= 36);
1668 ret = ret && (s->properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8);
1669 ret = ret && (s->properties.limits.maxDrawIndexedIndexValue >= 4294967295);
1670 ret = ret && (s->properties.limits.maxDrawIndirectCount >= 1);
1671 ret = ret && (s->properties.limits.maxFragmentCombinedOutputResources >= 8);
1672 ret = ret && (s->properties.limits.maxFragmentInputComponents >= 64);
1673 ret = ret && (s->properties.limits.maxFragmentOutputAttachments >= 4);
1674 ret = ret && (s->properties.limits.maxFramebufferHeight >= 4096);
1675 ret = ret && (s->properties.limits.maxFramebufferLayers >= 256);
1676 ret = ret && (s->properties.limits.maxFramebufferWidth >= 4096);
1677 ret = ret && (s->properties.limits.maxImageArrayLayers >= 256);
1678 ret = ret && (s->properties.limits.maxImageDimension1D >= 4096);
1679 ret = ret && (s->properties.limits.maxImageDimension2D >= 4096);
1680 ret = ret && (s->properties.limits.maxImageDimension3D >= 512);
1681 ret = ret && (s->properties.limits.maxImageDimensionCube >= 4096);
1682 ret = ret && (s->properties.limits.maxInterpolationOffset >= 0.4375);
1683 ret = ret && (s->properties.limits.maxMemoryAllocationCount >= 4096);
1684 ret = ret && (s->properties.limits.maxPerStageDescriptorInputAttachments >= 4);
1685 ret = ret && (s->properties.limits.maxPerStageDescriptorSampledImages >= 16);
1686 ret = ret && (s->properties.limits.maxPerStageDescriptorSamplers >= 16);
1687 ret = ret && (s->properties.limits.maxPerStageDescriptorStorageBuffers >= 4);
1688 ret = ret && (s->properties.limits.maxPerStageDescriptorStorageImages >= 4);
1689 ret = ret && (s->properties.limits.maxPerStageDescriptorUniformBuffers >= 12);
1690 ret = ret && (s->properties.limits.maxPerStageResources >= 44);
1691 ret = ret && (s->properties.limits.maxPushConstantsSize >= 128);
1692 ret = ret && (s->properties.limits.maxSampleMaskWords >= 1);
1693 ret = ret && (s->properties.limits.maxSamplerAllocationCount >= 4000);
1694 ret = ret && (s->properties.limits.maxSamplerAnisotropy >= 1.0);
1695 ret = ret && (s->properties.limits.maxSamplerLodBias >= 2.0);
1696 ret = ret && (s->properties.limits.maxStorageBufferRange >= 134217728);
1697 ret = ret && (s->properties.limits.maxTexelBufferElements >= 65536);
1698 ret = ret && (s->properties.limits.maxTexelOffset >= 7);
1699 ret = ret && (s->properties.limits.maxUniformBufferRange >= 16384);
1700 ret = ret && (s->properties.limits.maxVertexInputAttributeOffset >= 2047);
1701 ret = ret && (s->properties.limits.maxVertexInputAttributes >= 16);
1702 ret = ret && (s->properties.limits.maxVertexInputBindingStride >= 2048);
1703 ret = ret && (s->properties.limits.maxVertexInputBindings >= 16);
1704 ret = ret && (s->properties.limits.maxVertexOutputComponents >= 64);
1705 ret = ret && (s->properties.limits.maxViewportDimensions[0] >= 4096);
1706 ret = ret && (s->properties.limits.maxViewportDimensions[1] >= 4096);
1707 ret = ret && (s->properties.limits.maxViewports >= 1);
1708 ret = ret && (s->properties.limits.minInterpolationOffset <= -0.5);
1709 ret = ret && (s->properties.limits.minMemoryMapAlignment <= 4096);
1710 ret = ret && ((s->properties.limits.minMemoryMapAlignment & (s->properties.limits.minMemoryMapAlignment - 1)) == 0);
1711 ret = ret && (s->properties.limits.minStorageBufferOffsetAlignment <= 256);
1712 ret = ret && ((s->properties.limits.minStorageBufferOffsetAlignment & (s->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0);
1713 ret = ret && (s->properties.limits.minTexelBufferOffsetAlignment <= 256);
1714 ret = ret && ((s->properties.limits.minTexelBufferOffsetAlignment & (s->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0);
1715 ret = ret && (s->properties.limits.minTexelOffset <= -8);
1716 ret = ret && (s->properties.limits.minUniformBufferOffsetAlignment <= 256);
1717 ret = ret && ((s->properties.limits.minUniformBufferOffsetAlignment & (s->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0);
1718 ret = ret && (s->properties.limits.mipmapPrecisionBits >= 4);
1719 ret = ret && (s->properties.limits.pointSizeGranularity <= 1);
1720 ret = ret && (isMultiple(1, s->properties.limits.pointSizeGranularity));
1721 ret = ret && (vpCheckFlags(s->properties.limits.sampledImageColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)));
1722 ret = ret && (vpCheckFlags(s->properties.limits.sampledImageDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)));
1723 ret = ret && (vpCheckFlags(s->properties.limits.sampledImageIntegerSampleCounts, (VK_SAMPLE_COUNT_1_BIT)));
1724 ret = ret && (vpCheckFlags(s->properties.limits.sampledImageStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)));
1725 ret = ret && (s->properties.limits.standardSampleLocations == VK_TRUE);
1726 ret = ret && (vpCheckFlags(s->properties.limits.storageImageSampleCounts, (VK_SAMPLE_COUNT_1_BIT)));
1727 ret = ret && (s->properties.limits.subPixelInterpolationOffsetBits >= 4);
1728 ret = ret && (s->properties.limits.subPixelPrecisionBits >= 4);
1729 ret = ret && (s->properties.limits.subTexelPrecisionBits >= 4);
1730 ret = ret && (s->properties.limits.viewportBoundsRange[0] <= -8192);
1731 ret = ret && (s->properties.limits.viewportBoundsRange[1] >= 8191);
1732 } break;
1733 default: break;
1734 }
1735 return ret;
1736 }
1737 };
1738
1739 static const VpFormatDesc formatDesc[] = {
1740 {
1741 VK_FORMAT_A1R5G5B5_UNORM_PACK16,
__anon3431b7525102() 1742 [](VkBaseOutStructure* p) { (void)p;
1743 switch (p->sType) {
1744 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
1745 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
1746 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
1747 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
1748 } break;
1749 default: break;
1750 }
1751 },
__anon3431b7525202() 1752 [](VkBaseOutStructure* p) -> bool { (void)p;
1753 bool ret = true;
1754 switch (p->sType) {
1755 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
1756 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
1757 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
1758 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
1759 } break;
1760 default: break;
1761 }
1762 return ret;
1763 }
1764 },
1765 {
1766 VK_FORMAT_A2B10G10R10_UINT_PACK32,
__anon3431b7525302() 1767 [](VkBaseOutStructure* p) { (void)p;
1768 switch (p->sType) {
1769 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
1770 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
1771 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT);
1772 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
1773 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
1774 } break;
1775 default: break;
1776 }
1777 },
__anon3431b7525402() 1778 [](VkBaseOutStructure* p) -> bool { (void)p;
1779 bool ret = true;
1780 switch (p->sType) {
1781 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
1782 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
1783 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT)));
1784 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
1785 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
1786 } break;
1787 default: break;
1788 }
1789 return ret;
1790 }
1791 },
1792 {
1793 VK_FORMAT_A2B10G10R10_UNORM_PACK32,
__anon3431b7525502() 1794 [](VkBaseOutStructure* p) { (void)p;
1795 switch (p->sType) {
1796 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
1797 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
1798 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
1799 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
1800 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
1801 } break;
1802 default: break;
1803 }
1804 },
__anon3431b7525602() 1805 [](VkBaseOutStructure* p) -> bool { (void)p;
1806 bool ret = true;
1807 switch (p->sType) {
1808 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
1809 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
1810 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
1811 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
1812 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
1813 } break;
1814 default: break;
1815 }
1816 return ret;
1817 }
1818 },
1819 {
1820 VK_FORMAT_A8B8G8R8_SINT_PACK32,
__anon3431b7525702() 1821 [](VkBaseOutStructure* p) { (void)p;
1822 switch (p->sType) {
1823 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
1824 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
1825 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
1826 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
1827 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
1828 } break;
1829 default: break;
1830 }
1831 },
__anon3431b7525802() 1832 [](VkBaseOutStructure* p) -> bool { (void)p;
1833 bool ret = true;
1834 switch (p->sType) {
1835 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
1836 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
1837 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
1838 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
1839 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
1840 } break;
1841 default: break;
1842 }
1843 return ret;
1844 }
1845 },
1846 {
1847 VK_FORMAT_A8B8G8R8_SNORM_PACK32,
__anon3431b7525902() 1848 [](VkBaseOutStructure* p) { (void)p;
1849 switch (p->sType) {
1850 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
1851 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
1852 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
1853 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
1854 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
1855 } break;
1856 default: break;
1857 }
1858 },
__anon3431b7525a02() 1859 [](VkBaseOutStructure* p) -> bool { (void)p;
1860 bool ret = true;
1861 switch (p->sType) {
1862 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
1863 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
1864 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
1865 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
1866 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
1867 } break;
1868 default: break;
1869 }
1870 return ret;
1871 }
1872 },
1873 {
1874 VK_FORMAT_A8B8G8R8_SRGB_PACK32,
__anon3431b7525b02() 1875 [](VkBaseOutStructure* p) { (void)p;
1876 switch (p->sType) {
1877 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
1878 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
1879 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
1880 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
1881 } break;
1882 default: break;
1883 }
1884 },
__anon3431b7525c02() 1885 [](VkBaseOutStructure* p) -> bool { (void)p;
1886 bool ret = true;
1887 switch (p->sType) {
1888 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
1889 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
1890 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
1891 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
1892 } break;
1893 default: break;
1894 }
1895 return ret;
1896 }
1897 },
1898 {
1899 VK_FORMAT_A8B8G8R8_UINT_PACK32,
__anon3431b7525d02() 1900 [](VkBaseOutStructure* p) { (void)p;
1901 switch (p->sType) {
1902 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
1903 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
1904 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
1905 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
1906 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
1907 } break;
1908 default: break;
1909 }
1910 },
__anon3431b7525e02() 1911 [](VkBaseOutStructure* p) -> bool { (void)p;
1912 bool ret = true;
1913 switch (p->sType) {
1914 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
1915 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
1916 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
1917 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
1918 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
1919 } break;
1920 default: break;
1921 }
1922 return ret;
1923 }
1924 },
1925 {
1926 VK_FORMAT_A8B8G8R8_UNORM_PACK32,
__anon3431b7525f02() 1927 [](VkBaseOutStructure* p) { (void)p;
1928 switch (p->sType) {
1929 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
1930 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
1931 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
1932 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
1933 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
1934 } break;
1935 default: break;
1936 }
1937 },
__anon3431b7526002() 1938 [](VkBaseOutStructure* p) -> bool { (void)p;
1939 bool ret = true;
1940 switch (p->sType) {
1941 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
1942 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
1943 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
1944 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
1945 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
1946 } break;
1947 default: break;
1948 }
1949 return ret;
1950 }
1951 },
1952 {
1953 VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
__anon3431b7526102() 1954 [](VkBaseOutStructure* p) { (void)p;
1955 switch (p->sType) {
1956 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
1957 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
1958 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
1959 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
1960 } break;
1961 default: break;
1962 }
1963 },
__anon3431b7526202() 1964 [](VkBaseOutStructure* p) -> bool { (void)p;
1965 bool ret = true;
1966 switch (p->sType) {
1967 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
1968 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
1969 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
1970 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
1971 } break;
1972 default: break;
1973 }
1974 return ret;
1975 }
1976 },
1977 {
1978 VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
__anon3431b7526302() 1979 [](VkBaseOutStructure* p) { (void)p;
1980 switch (p->sType) {
1981 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
1982 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
1983 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
1984 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
1985 } break;
1986 default: break;
1987 }
1988 },
__anon3431b7526402() 1989 [](VkBaseOutStructure* p) -> bool { (void)p;
1990 bool ret = true;
1991 switch (p->sType) {
1992 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
1993 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
1994 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
1995 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
1996 } break;
1997 default: break;
1998 }
1999 return ret;
2000 }
2001 },
2002 {
2003 VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
__anon3431b7526502() 2004 [](VkBaseOutStructure* p) { (void)p;
2005 switch (p->sType) {
2006 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2007 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2008 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2009 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2010 } break;
2011 default: break;
2012 }
2013 },
__anon3431b7526602() 2014 [](VkBaseOutStructure* p) -> bool { (void)p;
2015 bool ret = true;
2016 switch (p->sType) {
2017 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2018 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2019 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2020 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2021 } break;
2022 default: break;
2023 }
2024 return ret;
2025 }
2026 },
2027 {
2028 VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
__anon3431b7526702() 2029 [](VkBaseOutStructure* p) { (void)p;
2030 switch (p->sType) {
2031 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2032 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2033 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2034 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2035 } break;
2036 default: break;
2037 }
2038 },
__anon3431b7526802() 2039 [](VkBaseOutStructure* p) -> bool { (void)p;
2040 bool ret = true;
2041 switch (p->sType) {
2042 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2043 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2044 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2045 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2046 } break;
2047 default: break;
2048 }
2049 return ret;
2050 }
2051 },
2052 {
2053 VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
__anon3431b7526902() 2054 [](VkBaseOutStructure* p) { (void)p;
2055 switch (p->sType) {
2056 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2057 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2058 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2059 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2060 } break;
2061 default: break;
2062 }
2063 },
__anon3431b7526a02() 2064 [](VkBaseOutStructure* p) -> bool { (void)p;
2065 bool ret = true;
2066 switch (p->sType) {
2067 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2068 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2069 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2070 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2071 } break;
2072 default: break;
2073 }
2074 return ret;
2075 }
2076 },
2077 {
2078 VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
__anon3431b7526b02() 2079 [](VkBaseOutStructure* p) { (void)p;
2080 switch (p->sType) {
2081 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2082 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2083 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2084 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2085 } break;
2086 default: break;
2087 }
2088 },
__anon3431b7526c02() 2089 [](VkBaseOutStructure* p) -> bool { (void)p;
2090 bool ret = true;
2091 switch (p->sType) {
2092 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2093 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2094 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2095 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2096 } break;
2097 default: break;
2098 }
2099 return ret;
2100 }
2101 },
2102 {
2103 VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
__anon3431b7526d02() 2104 [](VkBaseOutStructure* p) { (void)p;
2105 switch (p->sType) {
2106 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2107 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2108 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2109 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2110 } break;
2111 default: break;
2112 }
2113 },
__anon3431b7526e02() 2114 [](VkBaseOutStructure* p) -> bool { (void)p;
2115 bool ret = true;
2116 switch (p->sType) {
2117 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2118 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2119 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2120 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2121 } break;
2122 default: break;
2123 }
2124 return ret;
2125 }
2126 },
2127 {
2128 VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
__anon3431b7526f02() 2129 [](VkBaseOutStructure* p) { (void)p;
2130 switch (p->sType) {
2131 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2132 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2133 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2134 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2135 } break;
2136 default: break;
2137 }
2138 },
__anon3431b7527002() 2139 [](VkBaseOutStructure* p) -> bool { (void)p;
2140 bool ret = true;
2141 switch (p->sType) {
2142 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2143 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2144 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2145 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2146 } break;
2147 default: break;
2148 }
2149 return ret;
2150 }
2151 },
2152 {
2153 VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
__anon3431b7527102() 2154 [](VkBaseOutStructure* p) { (void)p;
2155 switch (p->sType) {
2156 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2157 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2158 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2159 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2160 } break;
2161 default: break;
2162 }
2163 },
__anon3431b7527202() 2164 [](VkBaseOutStructure* p) -> bool { (void)p;
2165 bool ret = true;
2166 switch (p->sType) {
2167 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2168 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2169 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2170 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2171 } break;
2172 default: break;
2173 }
2174 return ret;
2175 }
2176 },
2177 {
2178 VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
__anon3431b7527302() 2179 [](VkBaseOutStructure* p) { (void)p;
2180 switch (p->sType) {
2181 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2182 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2183 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2184 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2185 } break;
2186 default: break;
2187 }
2188 },
__anon3431b7527402() 2189 [](VkBaseOutStructure* p) -> bool { (void)p;
2190 bool ret = true;
2191 switch (p->sType) {
2192 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2193 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2194 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2195 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2196 } break;
2197 default: break;
2198 }
2199 return ret;
2200 }
2201 },
2202 {
2203 VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
__anon3431b7527502() 2204 [](VkBaseOutStructure* p) { (void)p;
2205 switch (p->sType) {
2206 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2207 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2208 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2209 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2210 } break;
2211 default: break;
2212 }
2213 },
__anon3431b7527602() 2214 [](VkBaseOutStructure* p) -> bool { (void)p;
2215 bool ret = true;
2216 switch (p->sType) {
2217 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2218 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2219 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2220 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2221 } break;
2222 default: break;
2223 }
2224 return ret;
2225 }
2226 },
2227 {
2228 VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
__anon3431b7527702() 2229 [](VkBaseOutStructure* p) { (void)p;
2230 switch (p->sType) {
2231 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2232 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2233 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2234 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2235 } break;
2236 default: break;
2237 }
2238 },
__anon3431b7527802() 2239 [](VkBaseOutStructure* p) -> bool { (void)p;
2240 bool ret = true;
2241 switch (p->sType) {
2242 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2243 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2244 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2245 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2246 } break;
2247 default: break;
2248 }
2249 return ret;
2250 }
2251 },
2252 {
2253 VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
__anon3431b7527902() 2254 [](VkBaseOutStructure* p) { (void)p;
2255 switch (p->sType) {
2256 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2257 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2258 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2259 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2260 } break;
2261 default: break;
2262 }
2263 },
__anon3431b7527a02() 2264 [](VkBaseOutStructure* p) -> bool { (void)p;
2265 bool ret = true;
2266 switch (p->sType) {
2267 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2268 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2269 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2270 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2271 } break;
2272 default: break;
2273 }
2274 return ret;
2275 }
2276 },
2277 {
2278 VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
__anon3431b7527b02() 2279 [](VkBaseOutStructure* p) { (void)p;
2280 switch (p->sType) {
2281 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2282 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2283 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2284 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2285 } break;
2286 default: break;
2287 }
2288 },
__anon3431b7527c02() 2289 [](VkBaseOutStructure* p) -> bool { (void)p;
2290 bool ret = true;
2291 switch (p->sType) {
2292 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2293 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2294 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2295 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2296 } break;
2297 default: break;
2298 }
2299 return ret;
2300 }
2301 },
2302 {
2303 VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
__anon3431b7527d02() 2304 [](VkBaseOutStructure* p) { (void)p;
2305 switch (p->sType) {
2306 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2307 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2308 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2309 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2310 } break;
2311 default: break;
2312 }
2313 },
__anon3431b7527e02() 2314 [](VkBaseOutStructure* p) -> bool { (void)p;
2315 bool ret = true;
2316 switch (p->sType) {
2317 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2318 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2319 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2320 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2321 } break;
2322 default: break;
2323 }
2324 return ret;
2325 }
2326 },
2327 {
2328 VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
__anon3431b7527f02() 2329 [](VkBaseOutStructure* p) { (void)p;
2330 switch (p->sType) {
2331 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2332 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2333 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2334 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2335 } break;
2336 default: break;
2337 }
2338 },
__anon3431b7528002() 2339 [](VkBaseOutStructure* p) -> bool { (void)p;
2340 bool ret = true;
2341 switch (p->sType) {
2342 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2343 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2344 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2345 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2346 } break;
2347 default: break;
2348 }
2349 return ret;
2350 }
2351 },
2352 {
2353 VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
__anon3431b7528102() 2354 [](VkBaseOutStructure* p) { (void)p;
2355 switch (p->sType) {
2356 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2357 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2358 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2359 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2360 } break;
2361 default: break;
2362 }
2363 },
__anon3431b7528202() 2364 [](VkBaseOutStructure* p) -> bool { (void)p;
2365 bool ret = true;
2366 switch (p->sType) {
2367 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2368 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2369 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2370 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2371 } break;
2372 default: break;
2373 }
2374 return ret;
2375 }
2376 },
2377 {
2378 VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
__anon3431b7528302() 2379 [](VkBaseOutStructure* p) { (void)p;
2380 switch (p->sType) {
2381 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2382 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2383 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2384 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2385 } break;
2386 default: break;
2387 }
2388 },
__anon3431b7528402() 2389 [](VkBaseOutStructure* p) -> bool { (void)p;
2390 bool ret = true;
2391 switch (p->sType) {
2392 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2393 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2394 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2395 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2396 } break;
2397 default: break;
2398 }
2399 return ret;
2400 }
2401 },
2402 {
2403 VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
__anon3431b7528502() 2404 [](VkBaseOutStructure* p) { (void)p;
2405 switch (p->sType) {
2406 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2407 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2408 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2409 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2410 } break;
2411 default: break;
2412 }
2413 },
__anon3431b7528602() 2414 [](VkBaseOutStructure* p) -> bool { (void)p;
2415 bool ret = true;
2416 switch (p->sType) {
2417 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2418 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2419 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2420 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2421 } break;
2422 default: break;
2423 }
2424 return ret;
2425 }
2426 },
2427 {
2428 VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
__anon3431b7528702() 2429 [](VkBaseOutStructure* p) { (void)p;
2430 switch (p->sType) {
2431 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2432 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2433 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2434 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2435 } break;
2436 default: break;
2437 }
2438 },
__anon3431b7528802() 2439 [](VkBaseOutStructure* p) -> bool { (void)p;
2440 bool ret = true;
2441 switch (p->sType) {
2442 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2443 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2444 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2445 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2446 } break;
2447 default: break;
2448 }
2449 return ret;
2450 }
2451 },
2452 {
2453 VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
__anon3431b7528902() 2454 [](VkBaseOutStructure* p) { (void)p;
2455 switch (p->sType) {
2456 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2457 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2458 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2459 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2460 } break;
2461 default: break;
2462 }
2463 },
__anon3431b7528a02() 2464 [](VkBaseOutStructure* p) -> bool { (void)p;
2465 bool ret = true;
2466 switch (p->sType) {
2467 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2468 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2469 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2470 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2471 } break;
2472 default: break;
2473 }
2474 return ret;
2475 }
2476 },
2477 {
2478 VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
__anon3431b7528b02() 2479 [](VkBaseOutStructure* p) { (void)p;
2480 switch (p->sType) {
2481 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2482 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2483 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2484 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2485 } break;
2486 default: break;
2487 }
2488 },
__anon3431b7528c02() 2489 [](VkBaseOutStructure* p) -> bool { (void)p;
2490 bool ret = true;
2491 switch (p->sType) {
2492 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2493 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2494 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2495 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2496 } break;
2497 default: break;
2498 }
2499 return ret;
2500 }
2501 },
2502 {
2503 VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
__anon3431b7528d02() 2504 [](VkBaseOutStructure* p) { (void)p;
2505 switch (p->sType) {
2506 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2507 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2508 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2509 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2510 } break;
2511 default: break;
2512 }
2513 },
__anon3431b7528e02() 2514 [](VkBaseOutStructure* p) -> bool { (void)p;
2515 bool ret = true;
2516 switch (p->sType) {
2517 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2518 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2519 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2520 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2521 } break;
2522 default: break;
2523 }
2524 return ret;
2525 }
2526 },
2527 {
2528 VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
__anon3431b7528f02() 2529 [](VkBaseOutStructure* p) { (void)p;
2530 switch (p->sType) {
2531 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2532 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2533 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2534 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2535 } break;
2536 default: break;
2537 }
2538 },
__anon3431b7529002() 2539 [](VkBaseOutStructure* p) -> bool { (void)p;
2540 bool ret = true;
2541 switch (p->sType) {
2542 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2543 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2544 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2545 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2546 } break;
2547 default: break;
2548 }
2549 return ret;
2550 }
2551 },
2552 {
2553 VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
__anon3431b7529102() 2554 [](VkBaseOutStructure* p) { (void)p;
2555 switch (p->sType) {
2556 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2557 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2558 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2559 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2560 } break;
2561 default: break;
2562 }
2563 },
__anon3431b7529202() 2564 [](VkBaseOutStructure* p) -> bool { (void)p;
2565 bool ret = true;
2566 switch (p->sType) {
2567 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2568 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2569 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2570 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2571 } break;
2572 default: break;
2573 }
2574 return ret;
2575 }
2576 },
2577 {
2578 VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
__anon3431b7529302() 2579 [](VkBaseOutStructure* p) { (void)p;
2580 switch (p->sType) {
2581 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2582 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2583 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2584 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2585 } break;
2586 default: break;
2587 }
2588 },
__anon3431b7529402() 2589 [](VkBaseOutStructure* p) -> bool { (void)p;
2590 bool ret = true;
2591 switch (p->sType) {
2592 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2593 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2594 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2595 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2596 } break;
2597 default: break;
2598 }
2599 return ret;
2600 }
2601 },
2602 {
2603 VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
__anon3431b7529502() 2604 [](VkBaseOutStructure* p) { (void)p;
2605 switch (p->sType) {
2606 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2607 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2608 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2609 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2610 } break;
2611 default: break;
2612 }
2613 },
__anon3431b7529602() 2614 [](VkBaseOutStructure* p) -> bool { (void)p;
2615 bool ret = true;
2616 switch (p->sType) {
2617 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2618 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2619 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2620 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2621 } break;
2622 default: break;
2623 }
2624 return ret;
2625 }
2626 },
2627 {
2628 VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
__anon3431b7529702() 2629 [](VkBaseOutStructure* p) { (void)p;
2630 switch (p->sType) {
2631 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2632 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2633 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2634 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2635 } break;
2636 default: break;
2637 }
2638 },
__anon3431b7529802() 2639 [](VkBaseOutStructure* p) -> bool { (void)p;
2640 bool ret = true;
2641 switch (p->sType) {
2642 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2643 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2644 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2645 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2646 } break;
2647 default: break;
2648 }
2649 return ret;
2650 }
2651 },
2652 {
2653 VK_FORMAT_B10G11R11_UFLOAT_PACK32,
__anon3431b7529902() 2654 [](VkBaseOutStructure* p) { (void)p;
2655 switch (p->sType) {
2656 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2657 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2658 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT);
2659 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2660 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2661 } break;
2662 default: break;
2663 }
2664 },
__anon3431b7529a02() 2665 [](VkBaseOutStructure* p) -> bool { (void)p;
2666 bool ret = true;
2667 switch (p->sType) {
2668 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2669 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2670 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT)));
2671 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2672 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2673 } break;
2674 default: break;
2675 }
2676 return ret;
2677 }
2678 },
2679 {
2680 VK_FORMAT_B4G4R4A4_UNORM_PACK16,
__anon3431b7529b02() 2681 [](VkBaseOutStructure* p) { (void)p;
2682 switch (p->sType) {
2683 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2684 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2685 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2686 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2687 } break;
2688 default: break;
2689 }
2690 },
__anon3431b7529c02() 2691 [](VkBaseOutStructure* p) -> bool { (void)p;
2692 bool ret = true;
2693 switch (p->sType) {
2694 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2695 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2696 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2697 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2698 } break;
2699 default: break;
2700 }
2701 return ret;
2702 }
2703 },
2704 {
2705 VK_FORMAT_B8G8R8A8_SRGB,
__anon3431b7529d02() 2706 [](VkBaseOutStructure* p) { (void)p;
2707 switch (p->sType) {
2708 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2709 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2710 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2711 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2712 } break;
2713 default: break;
2714 }
2715 },
__anon3431b7529e02() 2716 [](VkBaseOutStructure* p) -> bool { (void)p;
2717 bool ret = true;
2718 switch (p->sType) {
2719 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2720 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2721 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2722 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2723 } break;
2724 default: break;
2725 }
2726 return ret;
2727 }
2728 },
2729 {
2730 VK_FORMAT_B8G8R8A8_UNORM,
__anon3431b7529f02() 2731 [](VkBaseOutStructure* p) { (void)p;
2732 switch (p->sType) {
2733 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2734 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2735 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
2736 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2737 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2738 } break;
2739 default: break;
2740 }
2741 },
__anon3431b752a002() 2742 [](VkBaseOutStructure* p) -> bool { (void)p;
2743 bool ret = true;
2744 switch (p->sType) {
2745 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2746 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2747 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
2748 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2749 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2750 } break;
2751 default: break;
2752 }
2753 return ret;
2754 }
2755 },
2756 {
2757 VK_FORMAT_D16_UNORM,
__anon3431b752a102() 2758 [](VkBaseOutStructure* p) { (void)p;
2759 switch (p->sType) {
2760 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2761 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2762 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2763 } break;
2764 default: break;
2765 }
2766 },
__anon3431b752a202() 2767 [](VkBaseOutStructure* p) -> bool { (void)p;
2768 bool ret = true;
2769 switch (p->sType) {
2770 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2771 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2772 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2773 } break;
2774 default: break;
2775 }
2776 return ret;
2777 }
2778 },
2779 {
2780 VK_FORMAT_D32_SFLOAT,
__anon3431b752a302() 2781 [](VkBaseOutStructure* p) { (void)p;
2782 switch (p->sType) {
2783 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2784 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2785 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2786 } break;
2787 default: break;
2788 }
2789 },
__anon3431b752a402() 2790 [](VkBaseOutStructure* p) -> bool { (void)p;
2791 bool ret = true;
2792 switch (p->sType) {
2793 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2794 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2795 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2796 } break;
2797 default: break;
2798 }
2799 return ret;
2800 }
2801 },
2802 {
2803 VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
__anon3431b752a502() 2804 [](VkBaseOutStructure* p) { (void)p;
2805 switch (p->sType) {
2806 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2807 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2808 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2809 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2810 } break;
2811 default: break;
2812 }
2813 },
__anon3431b752a602() 2814 [](VkBaseOutStructure* p) -> bool { (void)p;
2815 bool ret = true;
2816 switch (p->sType) {
2817 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2818 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2819 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2820 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2821 } break;
2822 default: break;
2823 }
2824 return ret;
2825 }
2826 },
2827 {
2828 VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
__anon3431b752a702() 2829 [](VkBaseOutStructure* p) { (void)p;
2830 switch (p->sType) {
2831 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2832 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2833 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2834 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2835 } break;
2836 default: break;
2837 }
2838 },
__anon3431b752a802() 2839 [](VkBaseOutStructure* p) -> bool { (void)p;
2840 bool ret = true;
2841 switch (p->sType) {
2842 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2843 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2844 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2845 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2846 } break;
2847 default: break;
2848 }
2849 return ret;
2850 }
2851 },
2852 {
2853 VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
__anon3431b752a902() 2854 [](VkBaseOutStructure* p) { (void)p;
2855 switch (p->sType) {
2856 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2857 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2858 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2859 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2860 } break;
2861 default: break;
2862 }
2863 },
__anon3431b752aa02() 2864 [](VkBaseOutStructure* p) -> bool { (void)p;
2865 bool ret = true;
2866 switch (p->sType) {
2867 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2868 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2869 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2870 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2871 } break;
2872 default: break;
2873 }
2874 return ret;
2875 }
2876 },
2877 {
2878 VK_FORMAT_EAC_R11_SNORM_BLOCK,
__anon3431b752ab02() 2879 [](VkBaseOutStructure* p) { (void)p;
2880 switch (p->sType) {
2881 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2882 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2883 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2884 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2885 } break;
2886 default: break;
2887 }
2888 },
__anon3431b752ac02() 2889 [](VkBaseOutStructure* p) -> bool { (void)p;
2890 bool ret = true;
2891 switch (p->sType) {
2892 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2893 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2894 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2895 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2896 } break;
2897 default: break;
2898 }
2899 return ret;
2900 }
2901 },
2902 {
2903 VK_FORMAT_EAC_R11_UNORM_BLOCK,
__anon3431b752ad02() 2904 [](VkBaseOutStructure* p) { (void)p;
2905 switch (p->sType) {
2906 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2907 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2908 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2909 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2910 } break;
2911 default: break;
2912 }
2913 },
__anon3431b752ae02() 2914 [](VkBaseOutStructure* p) -> bool { (void)p;
2915 bool ret = true;
2916 switch (p->sType) {
2917 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2918 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2919 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2920 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2921 } break;
2922 default: break;
2923 }
2924 return ret;
2925 }
2926 },
2927 {
2928 VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
__anon3431b752af02() 2929 [](VkBaseOutStructure* p) { (void)p;
2930 switch (p->sType) {
2931 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2932 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2933 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2934 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2935 } break;
2936 default: break;
2937 }
2938 },
__anon3431b752b002() 2939 [](VkBaseOutStructure* p) -> bool { (void)p;
2940 bool ret = true;
2941 switch (p->sType) {
2942 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2943 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2944 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2945 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2946 } break;
2947 default: break;
2948 }
2949 return ret;
2950 }
2951 },
2952 {
2953 VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
__anon3431b752b102() 2954 [](VkBaseOutStructure* p) { (void)p;
2955 switch (p->sType) {
2956 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2957 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2958 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2959 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2960 } break;
2961 default: break;
2962 }
2963 },
__anon3431b752b202() 2964 [](VkBaseOutStructure* p) -> bool { (void)p;
2965 bool ret = true;
2966 switch (p->sType) {
2967 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2968 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2969 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2970 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2971 } break;
2972 default: break;
2973 }
2974 return ret;
2975 }
2976 },
2977 {
2978 VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,
__anon3431b752b302() 2979 [](VkBaseOutStructure* p) { (void)p;
2980 switch (p->sType) {
2981 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2982 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2983 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2984 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
2985 } break;
2986 default: break;
2987 }
2988 },
__anon3431b752b402() 2989 [](VkBaseOutStructure* p) -> bool { (void)p;
2990 bool ret = true;
2991 switch (p->sType) {
2992 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
2993 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
2994 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2995 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
2996 } break;
2997 default: break;
2998 }
2999 return ret;
3000 }
3001 },
3002 {
3003 VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
__anon3431b752b502() 3004 [](VkBaseOutStructure* p) { (void)p;
3005 switch (p->sType) {
3006 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3007 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3008 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3009 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3010 } break;
3011 default: break;
3012 }
3013 },
__anon3431b752b602() 3014 [](VkBaseOutStructure* p) -> bool { (void)p;
3015 bool ret = true;
3016 switch (p->sType) {
3017 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3018 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3019 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3020 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3021 } break;
3022 default: break;
3023 }
3024 return ret;
3025 }
3026 },
3027 {
3028 VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
__anon3431b752b702() 3029 [](VkBaseOutStructure* p) { (void)p;
3030 switch (p->sType) {
3031 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3032 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3033 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3034 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3035 } break;
3036 default: break;
3037 }
3038 },
__anon3431b752b802() 3039 [](VkBaseOutStructure* p) -> bool { (void)p;
3040 bool ret = true;
3041 switch (p->sType) {
3042 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3043 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3044 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3045 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3046 } break;
3047 default: break;
3048 }
3049 return ret;
3050 }
3051 },
3052 {
3053 VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
__anon3431b752b902() 3054 [](VkBaseOutStructure* p) { (void)p;
3055 switch (p->sType) {
3056 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3057 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3058 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3059 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3060 } break;
3061 default: break;
3062 }
3063 },
__anon3431b752ba02() 3064 [](VkBaseOutStructure* p) -> bool { (void)p;
3065 bool ret = true;
3066 switch (p->sType) {
3067 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3068 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3069 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3070 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3071 } break;
3072 default: break;
3073 }
3074 return ret;
3075 }
3076 },
3077 {
3078 VK_FORMAT_R16G16B16A16_SFLOAT,
__anon3431b752bb02() 3079 [](VkBaseOutStructure* p) { (void)p;
3080 switch (p->sType) {
3081 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3082 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3083 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3084 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3085 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3086 } break;
3087 default: break;
3088 }
3089 },
__anon3431b752bc02() 3090 [](VkBaseOutStructure* p) -> bool { (void)p;
3091 bool ret = true;
3092 switch (p->sType) {
3093 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3094 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3095 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3096 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3097 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3098 } break;
3099 default: break;
3100 }
3101 return ret;
3102 }
3103 },
3104 {
3105 VK_FORMAT_R16G16B16A16_SINT,
__anon3431b752bd02() 3106 [](VkBaseOutStructure* p) { (void)p;
3107 switch (p->sType) {
3108 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3109 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3110 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3111 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3112 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3113 } break;
3114 default: break;
3115 }
3116 },
__anon3431b752be02() 3117 [](VkBaseOutStructure* p) -> bool { (void)p;
3118 bool ret = true;
3119 switch (p->sType) {
3120 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3121 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3122 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3123 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3124 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3125 } break;
3126 default: break;
3127 }
3128 return ret;
3129 }
3130 },
3131 {
3132 VK_FORMAT_R16G16B16A16_SNORM,
__anon3431b752bf02() 3133 [](VkBaseOutStructure* p) { (void)p;
3134 switch (p->sType) {
3135 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3136 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3137 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3138 } break;
3139 default: break;
3140 }
3141 },
__anon3431b752c002() 3142 [](VkBaseOutStructure* p) -> bool { (void)p;
3143 bool ret = true;
3144 switch (p->sType) {
3145 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3146 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3147 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3148 } break;
3149 default: break;
3150 }
3151 return ret;
3152 }
3153 },
3154 {
3155 VK_FORMAT_R16G16B16A16_UINT,
__anon3431b752c102() 3156 [](VkBaseOutStructure* p) { (void)p;
3157 switch (p->sType) {
3158 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3159 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3160 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3161 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3162 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3163 } break;
3164 default: break;
3165 }
3166 },
__anon3431b752c202() 3167 [](VkBaseOutStructure* p) -> bool { (void)p;
3168 bool ret = true;
3169 switch (p->sType) {
3170 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3171 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3172 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3173 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3174 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3175 } break;
3176 default: break;
3177 }
3178 return ret;
3179 }
3180 },
3181 {
3182 VK_FORMAT_R16G16_SFLOAT,
__anon3431b752c302() 3183 [](VkBaseOutStructure* p) { (void)p;
3184 switch (p->sType) {
3185 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3186 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3187 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3188 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3189 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3190 } break;
3191 default: break;
3192 }
3193 },
__anon3431b752c402() 3194 [](VkBaseOutStructure* p) -> bool { (void)p;
3195 bool ret = true;
3196 switch (p->sType) {
3197 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3198 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3199 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3200 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3201 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3202 } break;
3203 default: break;
3204 }
3205 return ret;
3206 }
3207 },
3208 {
3209 VK_FORMAT_R16G16_SINT,
__anon3431b752c502() 3210 [](VkBaseOutStructure* p) { (void)p;
3211 switch (p->sType) {
3212 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3213 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3214 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3215 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3216 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3217 } break;
3218 default: break;
3219 }
3220 },
__anon3431b752c602() 3221 [](VkBaseOutStructure* p) -> bool { (void)p;
3222 bool ret = true;
3223 switch (p->sType) {
3224 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3225 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3226 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3227 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3228 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3229 } break;
3230 default: break;
3231 }
3232 return ret;
3233 }
3234 },
3235 {
3236 VK_FORMAT_R16G16_SNORM,
__anon3431b752c702() 3237 [](VkBaseOutStructure* p) { (void)p;
3238 switch (p->sType) {
3239 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3240 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3241 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3242 } break;
3243 default: break;
3244 }
3245 },
__anon3431b752c802() 3246 [](VkBaseOutStructure* p) -> bool { (void)p;
3247 bool ret = true;
3248 switch (p->sType) {
3249 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3250 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3251 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3252 } break;
3253 default: break;
3254 }
3255 return ret;
3256 }
3257 },
3258 {
3259 VK_FORMAT_R16G16_UINT,
__anon3431b752c902() 3260 [](VkBaseOutStructure* p) { (void)p;
3261 switch (p->sType) {
3262 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3263 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3264 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3265 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3266 } break;
3267 default: break;
3268 }
3269 },
__anon3431b752ca02() 3270 [](VkBaseOutStructure* p) -> bool { (void)p;
3271 bool ret = true;
3272 switch (p->sType) {
3273 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3274 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3275 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3276 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3277 } break;
3278 default: break;
3279 }
3280 return ret;
3281 }
3282 },
3283 {
3284 VK_FORMAT_R16_SFLOAT,
__anon3431b752cb02() 3285 [](VkBaseOutStructure* p) { (void)p;
3286 switch (p->sType) {
3287 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3288 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3289 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3290 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3291 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3292 } break;
3293 default: break;
3294 }
3295 },
__anon3431b752cc02() 3296 [](VkBaseOutStructure* p) -> bool { (void)p;
3297 bool ret = true;
3298 switch (p->sType) {
3299 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3300 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3301 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3302 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3303 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3304 } break;
3305 default: break;
3306 }
3307 return ret;
3308 }
3309 },
3310 {
3311 VK_FORMAT_R16_SINT,
__anon3431b752cd02() 3312 [](VkBaseOutStructure* p) { (void)p;
3313 switch (p->sType) {
3314 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3315 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3316 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3317 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3318 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3319 } break;
3320 default: break;
3321 }
3322 },
__anon3431b752ce02() 3323 [](VkBaseOutStructure* p) -> bool { (void)p;
3324 bool ret = true;
3325 switch (p->sType) {
3326 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3327 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3328 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3329 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3330 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3331 } break;
3332 default: break;
3333 }
3334 return ret;
3335 }
3336 },
3337 {
3338 VK_FORMAT_R16_SNORM,
__anon3431b752cf02() 3339 [](VkBaseOutStructure* p) { (void)p;
3340 switch (p->sType) {
3341 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3342 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3343 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3344 } break;
3345 default: break;
3346 }
3347 },
__anon3431b752d002() 3348 [](VkBaseOutStructure* p) -> bool { (void)p;
3349 bool ret = true;
3350 switch (p->sType) {
3351 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3352 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3353 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3354 } break;
3355 default: break;
3356 }
3357 return ret;
3358 }
3359 },
3360 {
3361 VK_FORMAT_R16_UINT,
__anon3431b752d102() 3362 [](VkBaseOutStructure* p) { (void)p;
3363 switch (p->sType) {
3364 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3365 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3366 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3367 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3368 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3369 } break;
3370 default: break;
3371 }
3372 },
__anon3431b752d202() 3373 [](VkBaseOutStructure* p) -> bool { (void)p;
3374 bool ret = true;
3375 switch (p->sType) {
3376 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3377 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3378 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3379 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3380 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3381 } break;
3382 default: break;
3383 }
3384 return ret;
3385 }
3386 },
3387 {
3388 VK_FORMAT_R16_UNORM,
__anon3431b752d302() 3389 [](VkBaseOutStructure* p) { (void)p;
3390 switch (p->sType) {
3391 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3392 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3393 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3394 } break;
3395 default: break;
3396 }
3397 },
__anon3431b752d402() 3398 [](VkBaseOutStructure* p) -> bool { (void)p;
3399 bool ret = true;
3400 switch (p->sType) {
3401 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3402 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3403 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3404 } break;
3405 default: break;
3406 }
3407 return ret;
3408 }
3409 },
3410 {
3411 VK_FORMAT_R32G32B32A32_SFLOAT,
__anon3431b752d502() 3412 [](VkBaseOutStructure* p) { (void)p;
3413 switch (p->sType) {
3414 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3415 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3416 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3417 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3418 } break;
3419 default: break;
3420 }
3421 },
__anon3431b752d602() 3422 [](VkBaseOutStructure* p) -> bool { (void)p;
3423 bool ret = true;
3424 switch (p->sType) {
3425 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3426 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3427 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3428 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3429 } break;
3430 default: break;
3431 }
3432 return ret;
3433 }
3434 },
3435 {
3436 VK_FORMAT_R32G32B32A32_SINT,
__anon3431b752d702() 3437 [](VkBaseOutStructure* p) { (void)p;
3438 switch (p->sType) {
3439 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3440 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3441 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3442 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3443 } break;
3444 default: break;
3445 }
3446 },
__anon3431b752d802() 3447 [](VkBaseOutStructure* p) -> bool { (void)p;
3448 bool ret = true;
3449 switch (p->sType) {
3450 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3451 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3452 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3453 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3454 } break;
3455 default: break;
3456 }
3457 return ret;
3458 }
3459 },
3460 {
3461 VK_FORMAT_R32G32B32A32_UINT,
__anon3431b752d902() 3462 [](VkBaseOutStructure* p) { (void)p;
3463 switch (p->sType) {
3464 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3465 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3466 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3467 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3468 } break;
3469 default: break;
3470 }
3471 },
__anon3431b752da02() 3472 [](VkBaseOutStructure* p) -> bool { (void)p;
3473 bool ret = true;
3474 switch (p->sType) {
3475 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3476 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3477 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3478 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3479 } break;
3480 default: break;
3481 }
3482 return ret;
3483 }
3484 },
3485 {
3486 VK_FORMAT_R32G32_SFLOAT,
__anon3431b752db02() 3487 [](VkBaseOutStructure* p) { (void)p;
3488 switch (p->sType) {
3489 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3490 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3491 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3492 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3493 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3494 } break;
3495 default: break;
3496 }
3497 },
__anon3431b752dc02() 3498 [](VkBaseOutStructure* p) -> bool { (void)p;
3499 bool ret = true;
3500 switch (p->sType) {
3501 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3502 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3503 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3504 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3505 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3506 } break;
3507 default: break;
3508 }
3509 return ret;
3510 }
3511 },
3512 {
3513 VK_FORMAT_R32G32_SINT,
__anon3431b752dd02() 3514 [](VkBaseOutStructure* p) { (void)p;
3515 switch (p->sType) {
3516 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3517 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3518 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3519 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3520 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3521 } break;
3522 default: break;
3523 }
3524 },
__anon3431b752de02() 3525 [](VkBaseOutStructure* p) -> bool { (void)p;
3526 bool ret = true;
3527 switch (p->sType) {
3528 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3529 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3530 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3531 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3532 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3533 } break;
3534 default: break;
3535 }
3536 return ret;
3537 }
3538 },
3539 {
3540 VK_FORMAT_R32G32_UINT,
__anon3431b752df02() 3541 [](VkBaseOutStructure* p) { (void)p;
3542 switch (p->sType) {
3543 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3544 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3545 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3546 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3547 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3548 } break;
3549 default: break;
3550 }
3551 },
__anon3431b752e002() 3552 [](VkBaseOutStructure* p) -> bool { (void)p;
3553 bool ret = true;
3554 switch (p->sType) {
3555 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3556 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3557 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3558 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3559 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3560 } break;
3561 default: break;
3562 }
3563 return ret;
3564 }
3565 },
3566 {
3567 VK_FORMAT_R32_SFLOAT,
__anon3431b752e102() 3568 [](VkBaseOutStructure* p) { (void)p;
3569 switch (p->sType) {
3570 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3571 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3572 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3573 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3574 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3575 } break;
3576 default: break;
3577 }
3578 },
__anon3431b752e202() 3579 [](VkBaseOutStructure* p) -> bool { (void)p;
3580 bool ret = true;
3581 switch (p->sType) {
3582 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3583 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3584 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3585 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3586 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3587 } break;
3588 default: break;
3589 }
3590 return ret;
3591 }
3592 },
3593 {
3594 VK_FORMAT_R32_SINT,
__anon3431b752e302() 3595 [](VkBaseOutStructure* p) { (void)p;
3596 switch (p->sType) {
3597 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3598 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3599 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3600 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3601 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3602 } break;
3603 default: break;
3604 }
3605 },
__anon3431b752e402() 3606 [](VkBaseOutStructure* p) -> bool { (void)p;
3607 bool ret = true;
3608 switch (p->sType) {
3609 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3610 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3611 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3612 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3613 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3614 } break;
3615 default: break;
3616 }
3617 return ret;
3618 }
3619 },
3620 {
3621 VK_FORMAT_R32_UINT,
__anon3431b752e502() 3622 [](VkBaseOutStructure* p) { (void)p;
3623 switch (p->sType) {
3624 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3625 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3626 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3627 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3628 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3629 } break;
3630 default: break;
3631 }
3632 },
__anon3431b752e602() 3633 [](VkBaseOutStructure* p) -> bool { (void)p;
3634 bool ret = true;
3635 switch (p->sType) {
3636 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3637 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3638 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3639 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3640 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3641 } break;
3642 default: break;
3643 }
3644 return ret;
3645 }
3646 },
3647 {
3648 VK_FORMAT_R5G6B5_UNORM_PACK16,
__anon3431b752e702() 3649 [](VkBaseOutStructure* p) { (void)p;
3650 switch (p->sType) {
3651 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3652 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3653 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3654 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3655 } break;
3656 default: break;
3657 }
3658 },
__anon3431b752e802() 3659 [](VkBaseOutStructure* p) -> bool { (void)p;
3660 bool ret = true;
3661 switch (p->sType) {
3662 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3663 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3664 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3665 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3666 } break;
3667 default: break;
3668 }
3669 return ret;
3670 }
3671 },
3672 {
3673 VK_FORMAT_R8G8B8A8_SINT,
__anon3431b752e902() 3674 [](VkBaseOutStructure* p) { (void)p;
3675 switch (p->sType) {
3676 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3677 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3678 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3679 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3680 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3681 } break;
3682 default: break;
3683 }
3684 },
__anon3431b752ea02() 3685 [](VkBaseOutStructure* p) -> bool { (void)p;
3686 bool ret = true;
3687 switch (p->sType) {
3688 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3689 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3690 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3691 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3692 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3693 } break;
3694 default: break;
3695 }
3696 return ret;
3697 }
3698 },
3699 {
3700 VK_FORMAT_R8G8B8A8_SNORM,
__anon3431b752eb02() 3701 [](VkBaseOutStructure* p) { (void)p;
3702 switch (p->sType) {
3703 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3704 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3705 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3706 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3707 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3708 } break;
3709 default: break;
3710 }
3711 },
__anon3431b752ec02() 3712 [](VkBaseOutStructure* p) -> bool { (void)p;
3713 bool ret = true;
3714 switch (p->sType) {
3715 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3716 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3717 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3718 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3719 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3720 } break;
3721 default: break;
3722 }
3723 return ret;
3724 }
3725 },
3726 {
3727 VK_FORMAT_R8G8B8A8_SRGB,
__anon3431b752ed02() 3728 [](VkBaseOutStructure* p) { (void)p;
3729 switch (p->sType) {
3730 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3731 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3732 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3733 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3734 } break;
3735 default: break;
3736 }
3737 },
__anon3431b752ee02() 3738 [](VkBaseOutStructure* p) -> bool { (void)p;
3739 bool ret = true;
3740 switch (p->sType) {
3741 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3742 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3743 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3744 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3745 } break;
3746 default: break;
3747 }
3748 return ret;
3749 }
3750 },
3751 {
3752 VK_FORMAT_R8G8B8A8_UINT,
__anon3431b752ef02() 3753 [](VkBaseOutStructure* p) { (void)p;
3754 switch (p->sType) {
3755 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3756 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3757 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3758 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3759 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3760 } break;
3761 default: break;
3762 }
3763 },
__anon3431b752f002() 3764 [](VkBaseOutStructure* p) -> bool { (void)p;
3765 bool ret = true;
3766 switch (p->sType) {
3767 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3768 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3769 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3770 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3771 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3772 } break;
3773 default: break;
3774 }
3775 return ret;
3776 }
3777 },
3778 {
3779 VK_FORMAT_R8G8B8A8_UNORM,
__anon3431b752f102() 3780 [](VkBaseOutStructure* p) { (void)p;
3781 switch (p->sType) {
3782 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3783 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3784 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3785 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3786 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3787 } break;
3788 default: break;
3789 }
3790 },
__anon3431b752f202() 3791 [](VkBaseOutStructure* p) -> bool { (void)p;
3792 bool ret = true;
3793 switch (p->sType) {
3794 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3795 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3796 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3797 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3798 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3799 } break;
3800 default: break;
3801 }
3802 return ret;
3803 }
3804 },
3805 {
3806 VK_FORMAT_R8G8_SINT,
__anon3431b752f302() 3807 [](VkBaseOutStructure* p) { (void)p;
3808 switch (p->sType) {
3809 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3810 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3811 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3812 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3813 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3814 } break;
3815 default: break;
3816 }
3817 },
__anon3431b752f402() 3818 [](VkBaseOutStructure* p) -> bool { (void)p;
3819 bool ret = true;
3820 switch (p->sType) {
3821 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3822 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3823 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3824 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3825 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3826 } break;
3827 default: break;
3828 }
3829 return ret;
3830 }
3831 },
3832 {
3833 VK_FORMAT_R8G8_SNORM,
__anon3431b752f502() 3834 [](VkBaseOutStructure* p) { (void)p;
3835 switch (p->sType) {
3836 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3837 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3838 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3839 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3840 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3841 } break;
3842 default: break;
3843 }
3844 },
__anon3431b752f602() 3845 [](VkBaseOutStructure* p) -> bool { (void)p;
3846 bool ret = true;
3847 switch (p->sType) {
3848 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3849 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3850 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3851 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3852 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3853 } break;
3854 default: break;
3855 }
3856 return ret;
3857 }
3858 },
3859 {
3860 VK_FORMAT_R8G8_UINT,
__anon3431b752f702() 3861 [](VkBaseOutStructure* p) { (void)p;
3862 switch (p->sType) {
3863 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3864 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3865 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3866 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3867 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3868 } break;
3869 default: break;
3870 }
3871 },
__anon3431b752f802() 3872 [](VkBaseOutStructure* p) -> bool { (void)p;
3873 bool ret = true;
3874 switch (p->sType) {
3875 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3876 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3877 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3878 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3879 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3880 } break;
3881 default: break;
3882 }
3883 return ret;
3884 }
3885 },
3886 {
3887 VK_FORMAT_R8G8_UNORM,
__anon3431b752f902() 3888 [](VkBaseOutStructure* p) { (void)p;
3889 switch (p->sType) {
3890 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3891 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3892 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3893 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3894 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3895 } break;
3896 default: break;
3897 }
3898 },
__anon3431b752fa02() 3899 [](VkBaseOutStructure* p) -> bool { (void)p;
3900 bool ret = true;
3901 switch (p->sType) {
3902 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3903 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3904 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3905 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3906 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3907 } break;
3908 default: break;
3909 }
3910 return ret;
3911 }
3912 },
3913 {
3914 VK_FORMAT_R8_SINT,
__anon3431b752fb02() 3915 [](VkBaseOutStructure* p) { (void)p;
3916 switch (p->sType) {
3917 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3918 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3919 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3920 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3921 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3922 } break;
3923 default: break;
3924 }
3925 },
__anon3431b752fc02() 3926 [](VkBaseOutStructure* p) -> bool { (void)p;
3927 bool ret = true;
3928 switch (p->sType) {
3929 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3930 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3931 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3932 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3933 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3934 } break;
3935 default: break;
3936 }
3937 return ret;
3938 }
3939 },
3940 {
3941 VK_FORMAT_R8_SNORM,
__anon3431b752fd02() 3942 [](VkBaseOutStructure* p) { (void)p;
3943 switch (p->sType) {
3944 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3945 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3946 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3947 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3948 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3949 } break;
3950 default: break;
3951 }
3952 },
__anon3431b752fe02() 3953 [](VkBaseOutStructure* p) -> bool { (void)p;
3954 bool ret = true;
3955 switch (p->sType) {
3956 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3957 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3958 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3959 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3960 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3961 } break;
3962 default: break;
3963 }
3964 return ret;
3965 }
3966 },
3967 {
3968 VK_FORMAT_R8_UINT,
__anon3431b752ff02() 3969 [](VkBaseOutStructure* p) { (void)p;
3970 switch (p->sType) {
3971 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3972 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3973 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
3974 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3975 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
3976 } break;
3977 default: break;
3978 }
3979 },
__anon3431b75210002() 3980 [](VkBaseOutStructure* p) -> bool { (void)p;
3981 bool ret = true;
3982 switch (p->sType) {
3983 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3984 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
3985 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
3986 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3987 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
3988 } break;
3989 default: break;
3990 }
3991 return ret;
3992 }
3993 },
3994 {
3995 VK_FORMAT_R8_UNORM,
__anon3431b75210102() 3996 [](VkBaseOutStructure* p) { (void)p;
3997 switch (p->sType) {
3998 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
3999 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4000 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
4001 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4002 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4003 } break;
4004 default: break;
4005 }
4006 },
__anon3431b75210202() 4007 [](VkBaseOutStructure* p) -> bool { (void)p;
4008 bool ret = true;
4009 switch (p->sType) {
4010 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4011 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4012 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
4013 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4014 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4015 } break;
4016 default: break;
4017 }
4018 return ret;
4019 }
4020 },
4021 };
4022
4023 static const VpStructChainerDesc chainerDesc = {
__anon3431b75210302() 4024 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
4025 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(nullptr));
4026 pfnCb(p, pUser);
4027 },
__anon3431b75210402() 4028 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
4029 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(nullptr));
4030 pfnCb(p, pUser);
4031 },
__anon3431b75210502() 4032 [](uint32_t count, VkBaseOutStructure* p, void* pUser, PFN_vpStructArrayChainerCb pfnCb) {
4033 pfnCb(count, p, pUser);
4034 },
__anon3431b75210602() 4035 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
4036 VkFormatProperties3KHR formatProperties3KHR{ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr };
4037 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(&formatProperties3KHR));
4038 pfnCb(p, pUser);
4039 },
4040 };
4041 } // namespace baseline
4042 } // namespace blocks
4043 } // namespace VP_ANDROID_BASELINE_2021
4044 #endif // VP_ANDROID_baseline_2021
4045
4046 #ifdef VP_ANDROID_baseline_2021_cpu_only
4047 namespace VP_ANDROID_BASELINE_2021_CPU_ONLY {
4048
4049 static const VkStructureType featureStructTypes[] = {
4050 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR,
4051 };
4052
4053 static const VkStructureType propertyStructTypes[] = {
4054 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR,
4055 };
4056
4057 static const VkStructureType formatStructTypes[] = {
4058 VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR,
4059 VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR,
4060 };
4061
4062 static const VkExtensionProperties instanceExtensions[] = {
4063 VkExtensionProperties{ VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME, 1 },
4064 VkExtensionProperties{ VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, 1 },
4065 VkExtensionProperties{ VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME, 1 },
4066 VkExtensionProperties{ VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, 1 },
4067 VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME, 1 },
4068 VkExtensionProperties{ VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, 1 },
4069 VkExtensionProperties{ VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, 1 },
4070 VkExtensionProperties{ VK_KHR_SURFACE_EXTENSION_NAME, 1 },
4071 };
4072
4073 static const VkExtensionProperties deviceExtensions[] = {
4074 VkExtensionProperties{ VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, 1 },
4075 VkExtensionProperties{ VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME, 1 },
4076 VkExtensionProperties{ VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME, 1 },
4077 VkExtensionProperties{ VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, 1 },
4078 VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME, 1 },
4079 VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME, 1 },
4080 VkExtensionProperties{ VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, 1 },
4081 VkExtensionProperties{ VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME, 1 },
4082 VkExtensionProperties{ VK_KHR_MAINTENANCE_1_EXTENSION_NAME, 1 },
4083 VkExtensionProperties{ VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME, 1 },
4084 VkExtensionProperties{ VK_KHR_SWAPCHAIN_EXTENSION_NAME, 1 },
4085 };
4086
4087 static const VpFeatureDesc featureDesc = {
__anon3431b75210702() 4088 [](VkBaseOutStructure* p) { (void)p;
4089 switch (p->sType) {
4090 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: {
4091 VkPhysicalDeviceFeatures2KHR* s = static_cast<VkPhysicalDeviceFeatures2KHR*>(static_cast<void*>(p));
4092 s->features.depthBiasClamp = VK_TRUE;
4093 s->features.fragmentStoresAndAtomics = VK_TRUE;
4094 s->features.fullDrawIndexUint32 = VK_TRUE;
4095 s->features.imageCubeArray = VK_TRUE;
4096 s->features.independentBlend = VK_TRUE;
4097 s->features.robustBufferAccess = VK_TRUE;
4098 s->features.sampleRateShading = VK_TRUE;
4099 s->features.shaderSampledImageArrayDynamicIndexing = VK_TRUE;
4100 s->features.shaderStorageImageArrayDynamicIndexing = VK_TRUE;
4101 s->features.shaderUniformBufferArrayDynamicIndexing = VK_TRUE;
4102 s->features.textureCompressionASTC_LDR = VK_TRUE;
4103 s->features.textureCompressionETC2 = VK_TRUE;
4104 } break;
4105 default: break;
4106 }
4107 },
__anon3431b75210802() 4108 [](VkBaseOutStructure* p) -> bool { (void)p;
4109 bool ret = true;
4110 switch (p->sType) {
4111 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: {
4112 VkPhysicalDeviceFeatures2KHR* s = static_cast<VkPhysicalDeviceFeatures2KHR*>(static_cast<void*>(p));
4113 ret = ret && (s->features.depthBiasClamp == VK_TRUE);
4114 ret = ret && (s->features.fragmentStoresAndAtomics == VK_TRUE);
4115 ret = ret && (s->features.fullDrawIndexUint32 == VK_TRUE);
4116 ret = ret && (s->features.imageCubeArray == VK_TRUE);
4117 ret = ret && (s->features.independentBlend == VK_TRUE);
4118 ret = ret && (s->features.robustBufferAccess == VK_TRUE);
4119 ret = ret && (s->features.sampleRateShading == VK_TRUE);
4120 ret = ret && (s->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE);
4121 ret = ret && (s->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE);
4122 ret = ret && (s->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE);
4123 ret = ret && (s->features.textureCompressionASTC_LDR == VK_TRUE);
4124 ret = ret && (s->features.textureCompressionETC2 == VK_TRUE);
4125 } break;
4126 default: break;
4127 }
4128 return ret;
4129 }
4130 };
4131
4132 static const VpPropertyDesc propertyDesc = {
__anon3431b75210902() 4133 [](VkBaseOutStructure* p) { (void)p;
4134 },
__anon3431b75210a02() 4135 [](VkBaseOutStructure* p) -> bool { (void)p;
4136 bool ret = true;
4137 return ret;
4138 }
4139 };
4140
4141 static const VpStructChainerDesc chainerDesc = {
__anon3431b75210b02() 4142 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
4143 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(nullptr));
4144 pfnCb(p, pUser);
4145 },
__anon3431b75210c02() 4146 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
4147 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(nullptr));
4148 pfnCb(p, pUser);
4149 },
__anon3431b75210d02() 4150 [](uint32_t count, VkBaseOutStructure* p, void* pUser, PFN_vpStructArrayChainerCb pfnCb) {
4151 pfnCb(count, p, pUser);
4152 },
__anon3431b75210e02() 4153 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
4154 VkFormatProperties3KHR formatProperties3KHR{ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr };
4155 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(&formatProperties3KHR));
4156 pfnCb(p, pUser);
4157 },
4158 };
4159
4160 namespace blocks {
4161 namespace baseline {
4162
4163 static const VkExtensionProperties instanceExtensions[] = {
4164 VkExtensionProperties{ VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME, 1 },
4165 VkExtensionProperties{ VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, 1 },
4166 VkExtensionProperties{ VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME, 1 },
4167 VkExtensionProperties{ VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, 1 },
4168 VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME, 1 },
4169 VkExtensionProperties{ VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, 1 },
4170 VkExtensionProperties{ VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, 1 },
4171 VkExtensionProperties{ VK_KHR_SURFACE_EXTENSION_NAME, 1 },
4172 };
4173
4174 static const VkExtensionProperties deviceExtensions[] = {
4175 VkExtensionProperties{ VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, 1 },
4176 VkExtensionProperties{ VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME, 1 },
4177 VkExtensionProperties{ VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME, 1 },
4178 VkExtensionProperties{ VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, 1 },
4179 VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME, 1 },
4180 VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME, 1 },
4181 VkExtensionProperties{ VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, 1 },
4182 VkExtensionProperties{ VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME, 1 },
4183 VkExtensionProperties{ VK_KHR_MAINTENANCE_1_EXTENSION_NAME, 1 },
4184 VkExtensionProperties{ VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME, 1 },
4185 VkExtensionProperties{ VK_KHR_SWAPCHAIN_EXTENSION_NAME, 1 },
4186 };
4187
4188 static const VpFeatureDesc featureDesc = {
__anon3431b75210f02() 4189 [](VkBaseOutStructure* p) { (void)p;
4190 switch (p->sType) {
4191 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: {
4192 VkPhysicalDeviceFeatures2KHR* s = static_cast<VkPhysicalDeviceFeatures2KHR*>(static_cast<void*>(p));
4193 s->features.depthBiasClamp = VK_TRUE;
4194 s->features.fragmentStoresAndAtomics = VK_TRUE;
4195 s->features.fullDrawIndexUint32 = VK_TRUE;
4196 s->features.imageCubeArray = VK_TRUE;
4197 s->features.independentBlend = VK_TRUE;
4198 s->features.robustBufferAccess = VK_TRUE;
4199 s->features.sampleRateShading = VK_TRUE;
4200 s->features.shaderSampledImageArrayDynamicIndexing = VK_TRUE;
4201 s->features.shaderStorageImageArrayDynamicIndexing = VK_TRUE;
4202 s->features.shaderUniformBufferArrayDynamicIndexing = VK_TRUE;
4203 s->features.textureCompressionASTC_LDR = VK_TRUE;
4204 s->features.textureCompressionETC2 = VK_TRUE;
4205 } break;
4206 default: break;
4207 }
4208 },
__anon3431b75211002() 4209 [](VkBaseOutStructure* p) -> bool { (void)p;
4210 bool ret = true;
4211 switch (p->sType) {
4212 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: {
4213 VkPhysicalDeviceFeatures2KHR* s = static_cast<VkPhysicalDeviceFeatures2KHR*>(static_cast<void*>(p));
4214 ret = ret && (s->features.depthBiasClamp == VK_TRUE);
4215 ret = ret && (s->features.fragmentStoresAndAtomics == VK_TRUE);
4216 ret = ret && (s->features.fullDrawIndexUint32 == VK_TRUE);
4217 ret = ret && (s->features.imageCubeArray == VK_TRUE);
4218 ret = ret && (s->features.independentBlend == VK_TRUE);
4219 ret = ret && (s->features.robustBufferAccess == VK_TRUE);
4220 ret = ret && (s->features.sampleRateShading == VK_TRUE);
4221 ret = ret && (s->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE);
4222 ret = ret && (s->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE);
4223 ret = ret && (s->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE);
4224 ret = ret && (s->features.textureCompressionASTC_LDR == VK_TRUE);
4225 ret = ret && (s->features.textureCompressionETC2 == VK_TRUE);
4226 } break;
4227 default: break;
4228 }
4229 return ret;
4230 }
4231 };
4232
4233 static const VpPropertyDesc propertyDesc = {
__anon3431b75211102() 4234 [](VkBaseOutStructure* p) { (void)p;
4235 switch (p->sType) {
4236 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: {
4237 VkPhysicalDeviceProperties2KHR* s = static_cast<VkPhysicalDeviceProperties2KHR*>(static_cast<void*>(p));
4238 s->properties.limits.discreteQueuePriorities = 2;
4239 s->properties.limits.framebufferColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT);
4240 s->properties.limits.framebufferDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT);
4241 s->properties.limits.framebufferNoAttachmentsSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT);
4242 s->properties.limits.framebufferStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT);
4243 s->properties.limits.maxBoundDescriptorSets = 4;
4244 s->properties.limits.maxColorAttachments = 4;
4245 s->properties.limits.maxComputeSharedMemorySize = 16384;
4246 s->properties.limits.maxComputeWorkGroupCount[0] = 65535;
4247 s->properties.limits.maxComputeWorkGroupCount[1] = 65535;
4248 s->properties.limits.maxComputeWorkGroupCount[2] = 65535;
4249 s->properties.limits.maxComputeWorkGroupInvocations = 128;
4250 s->properties.limits.maxComputeWorkGroupSize[0] = 128;
4251 s->properties.limits.maxComputeWorkGroupSize[1] = 128;
4252 s->properties.limits.maxComputeWorkGroupSize[2] = 64;
4253 s->properties.limits.maxDescriptorSetInputAttachments = 4;
4254 s->properties.limits.maxDescriptorSetSampledImages = 48;
4255 s->properties.limits.maxDescriptorSetSamplers = 48;
4256 s->properties.limits.maxDescriptorSetStorageBuffers = 24;
4257 s->properties.limits.maxDescriptorSetStorageBuffersDynamic = 4;
4258 s->properties.limits.maxDescriptorSetStorageImages = 12;
4259 s->properties.limits.maxDescriptorSetUniformBuffers = 36;
4260 s->properties.limits.maxDescriptorSetUniformBuffersDynamic = 8;
4261 s->properties.limits.maxDrawIndexedIndexValue = 4294967295;
4262 s->properties.limits.maxDrawIndirectCount = 1;
4263 s->properties.limits.maxFragmentCombinedOutputResources = 8;
4264 s->properties.limits.maxFragmentInputComponents = 64;
4265 s->properties.limits.maxFragmentOutputAttachments = 4;
4266 s->properties.limits.maxFramebufferHeight = 4096;
4267 s->properties.limits.maxFramebufferLayers = 256;
4268 s->properties.limits.maxFramebufferWidth = 4096;
4269 s->properties.limits.maxImageArrayLayers = 256;
4270 s->properties.limits.maxImageDimension1D = 4096;
4271 s->properties.limits.maxImageDimension2D = 4096;
4272 s->properties.limits.maxImageDimension3D = 512;
4273 s->properties.limits.maxImageDimensionCube = 4096;
4274 s->properties.limits.maxInterpolationOffset = 0.4375f;
4275 s->properties.limits.maxMemoryAllocationCount = 4096;
4276 s->properties.limits.maxPerStageDescriptorInputAttachments = 4;
4277 s->properties.limits.maxPerStageDescriptorSampledImages = 16;
4278 s->properties.limits.maxPerStageDescriptorSamplers = 16;
4279 s->properties.limits.maxPerStageDescriptorStorageBuffers = 4;
4280 s->properties.limits.maxPerStageDescriptorStorageImages = 4;
4281 s->properties.limits.maxPerStageDescriptorUniformBuffers = 12;
4282 s->properties.limits.maxPerStageResources = 44;
4283 s->properties.limits.maxPushConstantsSize = 128;
4284 s->properties.limits.maxSampleMaskWords = 1;
4285 s->properties.limits.maxSamplerAllocationCount = 4000;
4286 s->properties.limits.maxSamplerAnisotropy = 1.0f;
4287 s->properties.limits.maxSamplerLodBias = 2.0f;
4288 s->properties.limits.maxStorageBufferRange = 134217728;
4289 s->properties.limits.maxTexelBufferElements = 65536;
4290 s->properties.limits.maxTexelOffset = 7;
4291 s->properties.limits.maxUniformBufferRange = 16384;
4292 s->properties.limits.maxVertexInputAttributeOffset = 2047;
4293 s->properties.limits.maxVertexInputAttributes = 16;
4294 s->properties.limits.maxVertexInputBindingStride = 2048;
4295 s->properties.limits.maxVertexInputBindings = 16;
4296 s->properties.limits.maxVertexOutputComponents = 64;
4297 s->properties.limits.maxViewportDimensions[0] = 4096;
4298 s->properties.limits.maxViewportDimensions[1] = 4096;
4299 s->properties.limits.maxViewports = 1;
4300 s->properties.limits.minInterpolationOffset = -0.5f;
4301 s->properties.limits.minMemoryMapAlignment = 4096;
4302 s->properties.limits.minStorageBufferOffsetAlignment = 256;
4303 s->properties.limits.minTexelBufferOffsetAlignment = 256;
4304 s->properties.limits.minTexelOffset = -8;
4305 s->properties.limits.minUniformBufferOffsetAlignment = 256;
4306 s->properties.limits.mipmapPrecisionBits = 4;
4307 s->properties.limits.sampledImageColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT);
4308 s->properties.limits.sampledImageDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT);
4309 s->properties.limits.sampledImageIntegerSampleCounts |= (VK_SAMPLE_COUNT_1_BIT);
4310 s->properties.limits.sampledImageStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT);
4311 s->properties.limits.standardSampleLocations = VK_TRUE;
4312 s->properties.limits.storageImageSampleCounts |= (VK_SAMPLE_COUNT_1_BIT);
4313 s->properties.limits.subPixelInterpolationOffsetBits = 4;
4314 s->properties.limits.subPixelPrecisionBits = 4;
4315 s->properties.limits.subTexelPrecisionBits = 4;
4316 s->properties.limits.viewportBoundsRange[0] = -8192;
4317 s->properties.limits.viewportBoundsRange[1] = 8191;
4318 } break;
4319 default: break;
4320 }
4321 },
__anon3431b75211202() 4322 [](VkBaseOutStructure* p) -> bool { (void)p;
4323 bool ret = true;
4324 switch (p->sType) {
4325 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: {
4326 VkPhysicalDeviceProperties2KHR* s = static_cast<VkPhysicalDeviceProperties2KHR*>(static_cast<void*>(p));
4327 ret = ret && (s->properties.limits.discreteQueuePriorities >= 2);
4328 ret = ret && (vpCheckFlags(s->properties.limits.framebufferColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)));
4329 ret = ret && (vpCheckFlags(s->properties.limits.framebufferDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)));
4330 ret = ret && (vpCheckFlags(s->properties.limits.framebufferNoAttachmentsSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)));
4331 ret = ret && (vpCheckFlags(s->properties.limits.framebufferStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)));
4332 ret = ret && (s->properties.limits.maxBoundDescriptorSets >= 4);
4333 ret = ret && (s->properties.limits.maxColorAttachments >= 4);
4334 ret = ret && (s->properties.limits.maxComputeSharedMemorySize >= 16384);
4335 ret = ret && (s->properties.limits.maxComputeWorkGroupCount[0] >= 65535);
4336 ret = ret && (s->properties.limits.maxComputeWorkGroupCount[1] >= 65535);
4337 ret = ret && (s->properties.limits.maxComputeWorkGroupCount[2] >= 65535);
4338 ret = ret && (s->properties.limits.maxComputeWorkGroupInvocations >= 128);
4339 ret = ret && (s->properties.limits.maxComputeWorkGroupSize[0] >= 128);
4340 ret = ret && (s->properties.limits.maxComputeWorkGroupSize[1] >= 128);
4341 ret = ret && (s->properties.limits.maxComputeWorkGroupSize[2] >= 64);
4342 ret = ret && (s->properties.limits.maxDescriptorSetInputAttachments >= 4);
4343 ret = ret && (s->properties.limits.maxDescriptorSetSampledImages >= 48);
4344 ret = ret && (s->properties.limits.maxDescriptorSetSamplers >= 48);
4345 ret = ret && (s->properties.limits.maxDescriptorSetStorageBuffers >= 24);
4346 ret = ret && (s->properties.limits.maxDescriptorSetStorageBuffersDynamic >= 4);
4347 ret = ret && (s->properties.limits.maxDescriptorSetStorageImages >= 12);
4348 ret = ret && (s->properties.limits.maxDescriptorSetUniformBuffers >= 36);
4349 ret = ret && (s->properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8);
4350 ret = ret && (s->properties.limits.maxDrawIndexedIndexValue >= 4294967295);
4351 ret = ret && (s->properties.limits.maxDrawIndirectCount >= 1);
4352 ret = ret && (s->properties.limits.maxFragmentCombinedOutputResources >= 8);
4353 ret = ret && (s->properties.limits.maxFragmentInputComponents >= 64);
4354 ret = ret && (s->properties.limits.maxFragmentOutputAttachments >= 4);
4355 ret = ret && (s->properties.limits.maxFramebufferHeight >= 4096);
4356 ret = ret && (s->properties.limits.maxFramebufferLayers >= 256);
4357 ret = ret && (s->properties.limits.maxFramebufferWidth >= 4096);
4358 ret = ret && (s->properties.limits.maxImageArrayLayers >= 256);
4359 ret = ret && (s->properties.limits.maxImageDimension1D >= 4096);
4360 ret = ret && (s->properties.limits.maxImageDimension2D >= 4096);
4361 ret = ret && (s->properties.limits.maxImageDimension3D >= 512);
4362 ret = ret && (s->properties.limits.maxImageDimensionCube >= 4096);
4363 ret = ret && (s->properties.limits.maxInterpolationOffset >= 0.4375);
4364 ret = ret && (s->properties.limits.maxMemoryAllocationCount >= 4096);
4365 ret = ret && (s->properties.limits.maxPerStageDescriptorInputAttachments >= 4);
4366 ret = ret && (s->properties.limits.maxPerStageDescriptorSampledImages >= 16);
4367 ret = ret && (s->properties.limits.maxPerStageDescriptorSamplers >= 16);
4368 ret = ret && (s->properties.limits.maxPerStageDescriptorStorageBuffers >= 4);
4369 ret = ret && (s->properties.limits.maxPerStageDescriptorStorageImages >= 4);
4370 ret = ret && (s->properties.limits.maxPerStageDescriptorUniformBuffers >= 12);
4371 ret = ret && (s->properties.limits.maxPerStageResources >= 44);
4372 ret = ret && (s->properties.limits.maxPushConstantsSize >= 128);
4373 ret = ret && (s->properties.limits.maxSampleMaskWords >= 1);
4374 ret = ret && (s->properties.limits.maxSamplerAllocationCount >= 4000);
4375 ret = ret && (s->properties.limits.maxSamplerAnisotropy >= 1.0);
4376 ret = ret && (s->properties.limits.maxSamplerLodBias >= 2.0);
4377 ret = ret && (s->properties.limits.maxStorageBufferRange >= 134217728);
4378 ret = ret && (s->properties.limits.maxTexelBufferElements >= 65536);
4379 ret = ret && (s->properties.limits.maxTexelOffset >= 7);
4380 ret = ret && (s->properties.limits.maxUniformBufferRange >= 16384);
4381 ret = ret && (s->properties.limits.maxVertexInputAttributeOffset >= 2047);
4382 ret = ret && (s->properties.limits.maxVertexInputAttributes >= 16);
4383 ret = ret && (s->properties.limits.maxVertexInputBindingStride >= 2048);
4384 ret = ret && (s->properties.limits.maxVertexInputBindings >= 16);
4385 ret = ret && (s->properties.limits.maxVertexOutputComponents >= 64);
4386 ret = ret && (s->properties.limits.maxViewportDimensions[0] >= 4096);
4387 ret = ret && (s->properties.limits.maxViewportDimensions[1] >= 4096);
4388 ret = ret && (s->properties.limits.maxViewports >= 1);
4389 ret = ret && (s->properties.limits.minInterpolationOffset <= -0.5);
4390 ret = ret && (s->properties.limits.minMemoryMapAlignment <= 4096);
4391 ret = ret && ((s->properties.limits.minMemoryMapAlignment & (s->properties.limits.minMemoryMapAlignment - 1)) == 0);
4392 ret = ret && (s->properties.limits.minStorageBufferOffsetAlignment <= 256);
4393 ret = ret && ((s->properties.limits.minStorageBufferOffsetAlignment & (s->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0);
4394 ret = ret && (s->properties.limits.minTexelBufferOffsetAlignment <= 256);
4395 ret = ret && ((s->properties.limits.minTexelBufferOffsetAlignment & (s->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0);
4396 ret = ret && (s->properties.limits.minTexelOffset <= -8);
4397 ret = ret && (s->properties.limits.minUniformBufferOffsetAlignment <= 256);
4398 ret = ret && ((s->properties.limits.minUniformBufferOffsetAlignment & (s->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0);
4399 ret = ret && (s->properties.limits.mipmapPrecisionBits >= 4);
4400 ret = ret && (vpCheckFlags(s->properties.limits.sampledImageColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)));
4401 ret = ret && (vpCheckFlags(s->properties.limits.sampledImageDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)));
4402 ret = ret && (vpCheckFlags(s->properties.limits.sampledImageIntegerSampleCounts, (VK_SAMPLE_COUNT_1_BIT)));
4403 ret = ret && (vpCheckFlags(s->properties.limits.sampledImageStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)));
4404 ret = ret && (s->properties.limits.standardSampleLocations == VK_TRUE);
4405 ret = ret && (vpCheckFlags(s->properties.limits.storageImageSampleCounts, (VK_SAMPLE_COUNT_1_BIT)));
4406 ret = ret && (s->properties.limits.subPixelInterpolationOffsetBits >= 4);
4407 ret = ret && (s->properties.limits.subPixelPrecisionBits >= 4);
4408 ret = ret && (s->properties.limits.subTexelPrecisionBits >= 4);
4409 ret = ret && (s->properties.limits.viewportBoundsRange[0] <= -8192);
4410 ret = ret && (s->properties.limits.viewportBoundsRange[1] >= 8191);
4411 } break;
4412 default: break;
4413 }
4414 return ret;
4415 }
4416 };
4417
4418 static const VpFormatDesc formatDesc[] = {
4419 {
4420 VK_FORMAT_A1R5G5B5_UNORM_PACK16,
__anon3431b75211302() 4421 [](VkBaseOutStructure* p) { (void)p;
4422 switch (p->sType) {
4423 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4424 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4425 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4426 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4427 } break;
4428 default: break;
4429 }
4430 },
__anon3431b75211402() 4431 [](VkBaseOutStructure* p) -> bool { (void)p;
4432 bool ret = true;
4433 switch (p->sType) {
4434 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4435 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4436 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4437 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4438 } break;
4439 default: break;
4440 }
4441 return ret;
4442 }
4443 },
4444 {
4445 VK_FORMAT_A2B10G10R10_UINT_PACK32,
__anon3431b75211502() 4446 [](VkBaseOutStructure* p) { (void)p;
4447 switch (p->sType) {
4448 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4449 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4450 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT);
4451 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4452 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4453 } break;
4454 default: break;
4455 }
4456 },
__anon3431b75211602() 4457 [](VkBaseOutStructure* p) -> bool { (void)p;
4458 bool ret = true;
4459 switch (p->sType) {
4460 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4461 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4462 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT)));
4463 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4464 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4465 } break;
4466 default: break;
4467 }
4468 return ret;
4469 }
4470 },
4471 {
4472 VK_FORMAT_A2B10G10R10_UNORM_PACK32,
__anon3431b75211702() 4473 [](VkBaseOutStructure* p) { (void)p;
4474 switch (p->sType) {
4475 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4476 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4477 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
4478 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4479 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4480 } break;
4481 default: break;
4482 }
4483 },
__anon3431b75211802() 4484 [](VkBaseOutStructure* p) -> bool { (void)p;
4485 bool ret = true;
4486 switch (p->sType) {
4487 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4488 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4489 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
4490 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4491 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4492 } break;
4493 default: break;
4494 }
4495 return ret;
4496 }
4497 },
4498 {
4499 VK_FORMAT_A8B8G8R8_SINT_PACK32,
__anon3431b75211902() 4500 [](VkBaseOutStructure* p) { (void)p;
4501 switch (p->sType) {
4502 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4503 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4504 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
4505 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4506 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4507 } break;
4508 default: break;
4509 }
4510 },
__anon3431b75211a02() 4511 [](VkBaseOutStructure* p) -> bool { (void)p;
4512 bool ret = true;
4513 switch (p->sType) {
4514 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4515 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4516 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
4517 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4518 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4519 } break;
4520 default: break;
4521 }
4522 return ret;
4523 }
4524 },
4525 {
4526 VK_FORMAT_A8B8G8R8_SNORM_PACK32,
__anon3431b75211b02() 4527 [](VkBaseOutStructure* p) { (void)p;
4528 switch (p->sType) {
4529 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4530 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4531 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
4532 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4533 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4534 } break;
4535 default: break;
4536 }
4537 },
__anon3431b75211c02() 4538 [](VkBaseOutStructure* p) -> bool { (void)p;
4539 bool ret = true;
4540 switch (p->sType) {
4541 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4542 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4543 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
4544 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4545 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4546 } break;
4547 default: break;
4548 }
4549 return ret;
4550 }
4551 },
4552 {
4553 VK_FORMAT_A8B8G8R8_SRGB_PACK32,
__anon3431b75211d02() 4554 [](VkBaseOutStructure* p) { (void)p;
4555 switch (p->sType) {
4556 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4557 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4558 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4559 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4560 } break;
4561 default: break;
4562 }
4563 },
__anon3431b75211e02() 4564 [](VkBaseOutStructure* p) -> bool { (void)p;
4565 bool ret = true;
4566 switch (p->sType) {
4567 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4568 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4569 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4570 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4571 } break;
4572 default: break;
4573 }
4574 return ret;
4575 }
4576 },
4577 {
4578 VK_FORMAT_A8B8G8R8_UINT_PACK32,
__anon3431b75211f02() 4579 [](VkBaseOutStructure* p) { (void)p;
4580 switch (p->sType) {
4581 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4582 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4583 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
4584 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4585 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4586 } break;
4587 default: break;
4588 }
4589 },
__anon3431b75212002() 4590 [](VkBaseOutStructure* p) -> bool { (void)p;
4591 bool ret = true;
4592 switch (p->sType) {
4593 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4594 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4595 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
4596 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4597 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4598 } break;
4599 default: break;
4600 }
4601 return ret;
4602 }
4603 },
4604 {
4605 VK_FORMAT_A8B8G8R8_UNORM_PACK32,
__anon3431b75212102() 4606 [](VkBaseOutStructure* p) { (void)p;
4607 switch (p->sType) {
4608 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4609 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4610 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
4611 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4612 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4613 } break;
4614 default: break;
4615 }
4616 },
__anon3431b75212202() 4617 [](VkBaseOutStructure* p) -> bool { (void)p;
4618 bool ret = true;
4619 switch (p->sType) {
4620 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4621 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4622 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
4623 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4624 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4625 } break;
4626 default: break;
4627 }
4628 return ret;
4629 }
4630 },
4631 {
4632 VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
__anon3431b75212302() 4633 [](VkBaseOutStructure* p) { (void)p;
4634 switch (p->sType) {
4635 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4636 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4637 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4638 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4639 } break;
4640 default: break;
4641 }
4642 },
__anon3431b75212402() 4643 [](VkBaseOutStructure* p) -> bool { (void)p;
4644 bool ret = true;
4645 switch (p->sType) {
4646 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4647 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4648 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4649 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4650 } break;
4651 default: break;
4652 }
4653 return ret;
4654 }
4655 },
4656 {
4657 VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
__anon3431b75212502() 4658 [](VkBaseOutStructure* p) { (void)p;
4659 switch (p->sType) {
4660 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4661 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4662 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4663 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4664 } break;
4665 default: break;
4666 }
4667 },
__anon3431b75212602() 4668 [](VkBaseOutStructure* p) -> bool { (void)p;
4669 bool ret = true;
4670 switch (p->sType) {
4671 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4672 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4673 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4674 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4675 } break;
4676 default: break;
4677 }
4678 return ret;
4679 }
4680 },
4681 {
4682 VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
__anon3431b75212702() 4683 [](VkBaseOutStructure* p) { (void)p;
4684 switch (p->sType) {
4685 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4686 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4687 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4688 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4689 } break;
4690 default: break;
4691 }
4692 },
__anon3431b75212802() 4693 [](VkBaseOutStructure* p) -> bool { (void)p;
4694 bool ret = true;
4695 switch (p->sType) {
4696 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4697 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4698 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4699 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4700 } break;
4701 default: break;
4702 }
4703 return ret;
4704 }
4705 },
4706 {
4707 VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
__anon3431b75212902() 4708 [](VkBaseOutStructure* p) { (void)p;
4709 switch (p->sType) {
4710 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4711 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4712 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4713 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4714 } break;
4715 default: break;
4716 }
4717 },
__anon3431b75212a02() 4718 [](VkBaseOutStructure* p) -> bool { (void)p;
4719 bool ret = true;
4720 switch (p->sType) {
4721 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4722 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4723 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4724 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4725 } break;
4726 default: break;
4727 }
4728 return ret;
4729 }
4730 },
4731 {
4732 VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
__anon3431b75212b02() 4733 [](VkBaseOutStructure* p) { (void)p;
4734 switch (p->sType) {
4735 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4736 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4737 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4738 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4739 } break;
4740 default: break;
4741 }
4742 },
__anon3431b75212c02() 4743 [](VkBaseOutStructure* p) -> bool { (void)p;
4744 bool ret = true;
4745 switch (p->sType) {
4746 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4747 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4748 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4749 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4750 } break;
4751 default: break;
4752 }
4753 return ret;
4754 }
4755 },
4756 {
4757 VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
__anon3431b75212d02() 4758 [](VkBaseOutStructure* p) { (void)p;
4759 switch (p->sType) {
4760 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4761 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4762 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4763 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4764 } break;
4765 default: break;
4766 }
4767 },
__anon3431b75212e02() 4768 [](VkBaseOutStructure* p) -> bool { (void)p;
4769 bool ret = true;
4770 switch (p->sType) {
4771 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4772 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4773 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4774 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4775 } break;
4776 default: break;
4777 }
4778 return ret;
4779 }
4780 },
4781 {
4782 VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
__anon3431b75212f02() 4783 [](VkBaseOutStructure* p) { (void)p;
4784 switch (p->sType) {
4785 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4786 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4787 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4788 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4789 } break;
4790 default: break;
4791 }
4792 },
__anon3431b75213002() 4793 [](VkBaseOutStructure* p) -> bool { (void)p;
4794 bool ret = true;
4795 switch (p->sType) {
4796 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4797 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4798 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4799 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4800 } break;
4801 default: break;
4802 }
4803 return ret;
4804 }
4805 },
4806 {
4807 VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
__anon3431b75213102() 4808 [](VkBaseOutStructure* p) { (void)p;
4809 switch (p->sType) {
4810 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4811 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4812 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4813 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4814 } break;
4815 default: break;
4816 }
4817 },
__anon3431b75213202() 4818 [](VkBaseOutStructure* p) -> bool { (void)p;
4819 bool ret = true;
4820 switch (p->sType) {
4821 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4822 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4823 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4824 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4825 } break;
4826 default: break;
4827 }
4828 return ret;
4829 }
4830 },
4831 {
4832 VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
__anon3431b75213302() 4833 [](VkBaseOutStructure* p) { (void)p;
4834 switch (p->sType) {
4835 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4836 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4837 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4838 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4839 } break;
4840 default: break;
4841 }
4842 },
__anon3431b75213402() 4843 [](VkBaseOutStructure* p) -> bool { (void)p;
4844 bool ret = true;
4845 switch (p->sType) {
4846 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4847 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4848 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4849 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4850 } break;
4851 default: break;
4852 }
4853 return ret;
4854 }
4855 },
4856 {
4857 VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
__anon3431b75213502() 4858 [](VkBaseOutStructure* p) { (void)p;
4859 switch (p->sType) {
4860 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4861 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4862 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4863 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4864 } break;
4865 default: break;
4866 }
4867 },
__anon3431b75213602() 4868 [](VkBaseOutStructure* p) -> bool { (void)p;
4869 bool ret = true;
4870 switch (p->sType) {
4871 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4872 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4873 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4874 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4875 } break;
4876 default: break;
4877 }
4878 return ret;
4879 }
4880 },
4881 {
4882 VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
__anon3431b75213702() 4883 [](VkBaseOutStructure* p) { (void)p;
4884 switch (p->sType) {
4885 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4886 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4887 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4888 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4889 } break;
4890 default: break;
4891 }
4892 },
__anon3431b75213802() 4893 [](VkBaseOutStructure* p) -> bool { (void)p;
4894 bool ret = true;
4895 switch (p->sType) {
4896 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4897 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4898 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4899 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4900 } break;
4901 default: break;
4902 }
4903 return ret;
4904 }
4905 },
4906 {
4907 VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
__anon3431b75213902() 4908 [](VkBaseOutStructure* p) { (void)p;
4909 switch (p->sType) {
4910 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4911 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4912 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4913 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4914 } break;
4915 default: break;
4916 }
4917 },
__anon3431b75213a02() 4918 [](VkBaseOutStructure* p) -> bool { (void)p;
4919 bool ret = true;
4920 switch (p->sType) {
4921 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4922 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4923 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4924 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4925 } break;
4926 default: break;
4927 }
4928 return ret;
4929 }
4930 },
4931 {
4932 VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
__anon3431b75213b02() 4933 [](VkBaseOutStructure* p) { (void)p;
4934 switch (p->sType) {
4935 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4936 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4937 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4938 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4939 } break;
4940 default: break;
4941 }
4942 },
__anon3431b75213c02() 4943 [](VkBaseOutStructure* p) -> bool { (void)p;
4944 bool ret = true;
4945 switch (p->sType) {
4946 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4947 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4948 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4949 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4950 } break;
4951 default: break;
4952 }
4953 return ret;
4954 }
4955 },
4956 {
4957 VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
__anon3431b75213d02() 4958 [](VkBaseOutStructure* p) { (void)p;
4959 switch (p->sType) {
4960 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4961 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4962 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4963 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4964 } break;
4965 default: break;
4966 }
4967 },
__anon3431b75213e02() 4968 [](VkBaseOutStructure* p) -> bool { (void)p;
4969 bool ret = true;
4970 switch (p->sType) {
4971 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4972 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4973 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4974 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4975 } break;
4976 default: break;
4977 }
4978 return ret;
4979 }
4980 },
4981 {
4982 VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
__anon3431b75213f02() 4983 [](VkBaseOutStructure* p) { (void)p;
4984 switch (p->sType) {
4985 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4986 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4987 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4988 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
4989 } break;
4990 default: break;
4991 }
4992 },
__anon3431b75214002() 4993 [](VkBaseOutStructure* p) -> bool { (void)p;
4994 bool ret = true;
4995 switch (p->sType) {
4996 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
4997 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
4998 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
4999 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5000 } break;
5001 default: break;
5002 }
5003 return ret;
5004 }
5005 },
5006 {
5007 VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
__anon3431b75214102() 5008 [](VkBaseOutStructure* p) { (void)p;
5009 switch (p->sType) {
5010 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5011 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5012 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5013 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5014 } break;
5015 default: break;
5016 }
5017 },
__anon3431b75214202() 5018 [](VkBaseOutStructure* p) -> bool { (void)p;
5019 bool ret = true;
5020 switch (p->sType) {
5021 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5022 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5023 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5024 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5025 } break;
5026 default: break;
5027 }
5028 return ret;
5029 }
5030 },
5031 {
5032 VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
__anon3431b75214302() 5033 [](VkBaseOutStructure* p) { (void)p;
5034 switch (p->sType) {
5035 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5036 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5037 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5038 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5039 } break;
5040 default: break;
5041 }
5042 },
__anon3431b75214402() 5043 [](VkBaseOutStructure* p) -> bool { (void)p;
5044 bool ret = true;
5045 switch (p->sType) {
5046 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5047 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5048 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5049 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5050 } break;
5051 default: break;
5052 }
5053 return ret;
5054 }
5055 },
5056 {
5057 VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
__anon3431b75214502() 5058 [](VkBaseOutStructure* p) { (void)p;
5059 switch (p->sType) {
5060 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5061 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5062 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5063 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5064 } break;
5065 default: break;
5066 }
5067 },
__anon3431b75214602() 5068 [](VkBaseOutStructure* p) -> bool { (void)p;
5069 bool ret = true;
5070 switch (p->sType) {
5071 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5072 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5073 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5074 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5075 } break;
5076 default: break;
5077 }
5078 return ret;
5079 }
5080 },
5081 {
5082 VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
__anon3431b75214702() 5083 [](VkBaseOutStructure* p) { (void)p;
5084 switch (p->sType) {
5085 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5086 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5087 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5088 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5089 } break;
5090 default: break;
5091 }
5092 },
__anon3431b75214802() 5093 [](VkBaseOutStructure* p) -> bool { (void)p;
5094 bool ret = true;
5095 switch (p->sType) {
5096 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5097 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5098 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5099 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5100 } break;
5101 default: break;
5102 }
5103 return ret;
5104 }
5105 },
5106 {
5107 VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
__anon3431b75214902() 5108 [](VkBaseOutStructure* p) { (void)p;
5109 switch (p->sType) {
5110 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5111 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5112 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5113 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5114 } break;
5115 default: break;
5116 }
5117 },
__anon3431b75214a02() 5118 [](VkBaseOutStructure* p) -> bool { (void)p;
5119 bool ret = true;
5120 switch (p->sType) {
5121 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5122 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5123 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5124 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5125 } break;
5126 default: break;
5127 }
5128 return ret;
5129 }
5130 },
5131 {
5132 VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
__anon3431b75214b02() 5133 [](VkBaseOutStructure* p) { (void)p;
5134 switch (p->sType) {
5135 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5136 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5137 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5138 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5139 } break;
5140 default: break;
5141 }
5142 },
__anon3431b75214c02() 5143 [](VkBaseOutStructure* p) -> bool { (void)p;
5144 bool ret = true;
5145 switch (p->sType) {
5146 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5147 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5148 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5149 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5150 } break;
5151 default: break;
5152 }
5153 return ret;
5154 }
5155 },
5156 {
5157 VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
__anon3431b75214d02() 5158 [](VkBaseOutStructure* p) { (void)p;
5159 switch (p->sType) {
5160 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5161 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5162 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5163 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5164 } break;
5165 default: break;
5166 }
5167 },
__anon3431b75214e02() 5168 [](VkBaseOutStructure* p) -> bool { (void)p;
5169 bool ret = true;
5170 switch (p->sType) {
5171 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5172 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5173 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5174 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5175 } break;
5176 default: break;
5177 }
5178 return ret;
5179 }
5180 },
5181 {
5182 VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
__anon3431b75214f02() 5183 [](VkBaseOutStructure* p) { (void)p;
5184 switch (p->sType) {
5185 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5186 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5187 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5188 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5189 } break;
5190 default: break;
5191 }
5192 },
__anon3431b75215002() 5193 [](VkBaseOutStructure* p) -> bool { (void)p;
5194 bool ret = true;
5195 switch (p->sType) {
5196 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5197 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5198 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5199 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5200 } break;
5201 default: break;
5202 }
5203 return ret;
5204 }
5205 },
5206 {
5207 VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
__anon3431b75215102() 5208 [](VkBaseOutStructure* p) { (void)p;
5209 switch (p->sType) {
5210 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5211 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5212 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5213 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5214 } break;
5215 default: break;
5216 }
5217 },
__anon3431b75215202() 5218 [](VkBaseOutStructure* p) -> bool { (void)p;
5219 bool ret = true;
5220 switch (p->sType) {
5221 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5222 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5223 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5224 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5225 } break;
5226 default: break;
5227 }
5228 return ret;
5229 }
5230 },
5231 {
5232 VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
__anon3431b75215302() 5233 [](VkBaseOutStructure* p) { (void)p;
5234 switch (p->sType) {
5235 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5236 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5237 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5238 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5239 } break;
5240 default: break;
5241 }
5242 },
__anon3431b75215402() 5243 [](VkBaseOutStructure* p) -> bool { (void)p;
5244 bool ret = true;
5245 switch (p->sType) {
5246 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5247 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5248 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5249 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5250 } break;
5251 default: break;
5252 }
5253 return ret;
5254 }
5255 },
5256 {
5257 VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
__anon3431b75215502() 5258 [](VkBaseOutStructure* p) { (void)p;
5259 switch (p->sType) {
5260 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5261 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5262 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5263 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5264 } break;
5265 default: break;
5266 }
5267 },
__anon3431b75215602() 5268 [](VkBaseOutStructure* p) -> bool { (void)p;
5269 bool ret = true;
5270 switch (p->sType) {
5271 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5272 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5273 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5274 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5275 } break;
5276 default: break;
5277 }
5278 return ret;
5279 }
5280 },
5281 {
5282 VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
__anon3431b75215702() 5283 [](VkBaseOutStructure* p) { (void)p;
5284 switch (p->sType) {
5285 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5286 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5287 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5288 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5289 } break;
5290 default: break;
5291 }
5292 },
__anon3431b75215802() 5293 [](VkBaseOutStructure* p) -> bool { (void)p;
5294 bool ret = true;
5295 switch (p->sType) {
5296 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5297 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5298 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5299 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5300 } break;
5301 default: break;
5302 }
5303 return ret;
5304 }
5305 },
5306 {
5307 VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
__anon3431b75215902() 5308 [](VkBaseOutStructure* p) { (void)p;
5309 switch (p->sType) {
5310 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5311 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5312 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5313 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5314 } break;
5315 default: break;
5316 }
5317 },
__anon3431b75215a02() 5318 [](VkBaseOutStructure* p) -> bool { (void)p;
5319 bool ret = true;
5320 switch (p->sType) {
5321 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5322 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5323 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5324 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5325 } break;
5326 default: break;
5327 }
5328 return ret;
5329 }
5330 },
5331 {
5332 VK_FORMAT_B10G11R11_UFLOAT_PACK32,
__anon3431b75215b02() 5333 [](VkBaseOutStructure* p) { (void)p;
5334 switch (p->sType) {
5335 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5336 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5337 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT);
5338 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5339 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5340 } break;
5341 default: break;
5342 }
5343 },
__anon3431b75215c02() 5344 [](VkBaseOutStructure* p) -> bool { (void)p;
5345 bool ret = true;
5346 switch (p->sType) {
5347 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5348 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5349 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT)));
5350 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5351 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5352 } break;
5353 default: break;
5354 }
5355 return ret;
5356 }
5357 },
5358 {
5359 VK_FORMAT_B4G4R4A4_UNORM_PACK16,
__anon3431b75215d02() 5360 [](VkBaseOutStructure* p) { (void)p;
5361 switch (p->sType) {
5362 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5363 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5364 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5365 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5366 } break;
5367 default: break;
5368 }
5369 },
__anon3431b75215e02() 5370 [](VkBaseOutStructure* p) -> bool { (void)p;
5371 bool ret = true;
5372 switch (p->sType) {
5373 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5374 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5375 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5376 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5377 } break;
5378 default: break;
5379 }
5380 return ret;
5381 }
5382 },
5383 {
5384 VK_FORMAT_B8G8R8A8_SRGB,
__anon3431b75215f02() 5385 [](VkBaseOutStructure* p) { (void)p;
5386 switch (p->sType) {
5387 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5388 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5389 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5390 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5391 } break;
5392 default: break;
5393 }
5394 },
__anon3431b75216002() 5395 [](VkBaseOutStructure* p) -> bool { (void)p;
5396 bool ret = true;
5397 switch (p->sType) {
5398 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5399 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5400 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5401 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5402 } break;
5403 default: break;
5404 }
5405 return ret;
5406 }
5407 },
5408 {
5409 VK_FORMAT_B8G8R8A8_UNORM,
__anon3431b75216102() 5410 [](VkBaseOutStructure* p) { (void)p;
5411 switch (p->sType) {
5412 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5413 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5414 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
5415 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5416 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5417 } break;
5418 default: break;
5419 }
5420 },
__anon3431b75216202() 5421 [](VkBaseOutStructure* p) -> bool { (void)p;
5422 bool ret = true;
5423 switch (p->sType) {
5424 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5425 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5426 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
5427 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5428 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5429 } break;
5430 default: break;
5431 }
5432 return ret;
5433 }
5434 },
5435 {
5436 VK_FORMAT_D16_UNORM,
__anon3431b75216302() 5437 [](VkBaseOutStructure* p) { (void)p;
5438 switch (p->sType) {
5439 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5440 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5441 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5442 } break;
5443 default: break;
5444 }
5445 },
__anon3431b75216402() 5446 [](VkBaseOutStructure* p) -> bool { (void)p;
5447 bool ret = true;
5448 switch (p->sType) {
5449 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5450 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5451 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5452 } break;
5453 default: break;
5454 }
5455 return ret;
5456 }
5457 },
5458 {
5459 VK_FORMAT_D32_SFLOAT,
__anon3431b75216502() 5460 [](VkBaseOutStructure* p) { (void)p;
5461 switch (p->sType) {
5462 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5463 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5464 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5465 } break;
5466 default: break;
5467 }
5468 },
__anon3431b75216602() 5469 [](VkBaseOutStructure* p) -> bool { (void)p;
5470 bool ret = true;
5471 switch (p->sType) {
5472 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5473 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5474 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5475 } break;
5476 default: break;
5477 }
5478 return ret;
5479 }
5480 },
5481 {
5482 VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
__anon3431b75216702() 5483 [](VkBaseOutStructure* p) { (void)p;
5484 switch (p->sType) {
5485 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5486 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5487 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5488 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5489 } break;
5490 default: break;
5491 }
5492 },
__anon3431b75216802() 5493 [](VkBaseOutStructure* p) -> bool { (void)p;
5494 bool ret = true;
5495 switch (p->sType) {
5496 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5497 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5498 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5499 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5500 } break;
5501 default: break;
5502 }
5503 return ret;
5504 }
5505 },
5506 {
5507 VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
__anon3431b75216902() 5508 [](VkBaseOutStructure* p) { (void)p;
5509 switch (p->sType) {
5510 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5511 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5512 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5513 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5514 } break;
5515 default: break;
5516 }
5517 },
__anon3431b75216a02() 5518 [](VkBaseOutStructure* p) -> bool { (void)p;
5519 bool ret = true;
5520 switch (p->sType) {
5521 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5522 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5523 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5524 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5525 } break;
5526 default: break;
5527 }
5528 return ret;
5529 }
5530 },
5531 {
5532 VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
__anon3431b75216b02() 5533 [](VkBaseOutStructure* p) { (void)p;
5534 switch (p->sType) {
5535 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5536 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5537 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5538 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5539 } break;
5540 default: break;
5541 }
5542 },
__anon3431b75216c02() 5543 [](VkBaseOutStructure* p) -> bool { (void)p;
5544 bool ret = true;
5545 switch (p->sType) {
5546 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5547 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5548 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5549 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5550 } break;
5551 default: break;
5552 }
5553 return ret;
5554 }
5555 },
5556 {
5557 VK_FORMAT_EAC_R11_SNORM_BLOCK,
__anon3431b75216d02() 5558 [](VkBaseOutStructure* p) { (void)p;
5559 switch (p->sType) {
5560 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5561 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5562 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5563 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5564 } break;
5565 default: break;
5566 }
5567 },
__anon3431b75216e02() 5568 [](VkBaseOutStructure* p) -> bool { (void)p;
5569 bool ret = true;
5570 switch (p->sType) {
5571 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5572 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5573 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5574 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5575 } break;
5576 default: break;
5577 }
5578 return ret;
5579 }
5580 },
5581 {
5582 VK_FORMAT_EAC_R11_UNORM_BLOCK,
__anon3431b75216f02() 5583 [](VkBaseOutStructure* p) { (void)p;
5584 switch (p->sType) {
5585 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5586 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5587 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5588 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5589 } break;
5590 default: break;
5591 }
5592 },
__anon3431b75217002() 5593 [](VkBaseOutStructure* p) -> bool { (void)p;
5594 bool ret = true;
5595 switch (p->sType) {
5596 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5597 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5598 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5599 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5600 } break;
5601 default: break;
5602 }
5603 return ret;
5604 }
5605 },
5606 {
5607 VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
__anon3431b75217102() 5608 [](VkBaseOutStructure* p) { (void)p;
5609 switch (p->sType) {
5610 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5611 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5612 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5613 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5614 } break;
5615 default: break;
5616 }
5617 },
__anon3431b75217202() 5618 [](VkBaseOutStructure* p) -> bool { (void)p;
5619 bool ret = true;
5620 switch (p->sType) {
5621 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5622 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5623 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5624 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5625 } break;
5626 default: break;
5627 }
5628 return ret;
5629 }
5630 },
5631 {
5632 VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
__anon3431b75217302() 5633 [](VkBaseOutStructure* p) { (void)p;
5634 switch (p->sType) {
5635 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5636 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5637 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5638 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5639 } break;
5640 default: break;
5641 }
5642 },
__anon3431b75217402() 5643 [](VkBaseOutStructure* p) -> bool { (void)p;
5644 bool ret = true;
5645 switch (p->sType) {
5646 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5647 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5648 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5649 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5650 } break;
5651 default: break;
5652 }
5653 return ret;
5654 }
5655 },
5656 {
5657 VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,
__anon3431b75217502() 5658 [](VkBaseOutStructure* p) { (void)p;
5659 switch (p->sType) {
5660 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5661 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5662 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5663 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5664 } break;
5665 default: break;
5666 }
5667 },
__anon3431b75217602() 5668 [](VkBaseOutStructure* p) -> bool { (void)p;
5669 bool ret = true;
5670 switch (p->sType) {
5671 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5672 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5673 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5674 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5675 } break;
5676 default: break;
5677 }
5678 return ret;
5679 }
5680 },
5681 {
5682 VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
__anon3431b75217702() 5683 [](VkBaseOutStructure* p) { (void)p;
5684 switch (p->sType) {
5685 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5686 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5687 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5688 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5689 } break;
5690 default: break;
5691 }
5692 },
__anon3431b75217802() 5693 [](VkBaseOutStructure* p) -> bool { (void)p;
5694 bool ret = true;
5695 switch (p->sType) {
5696 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5697 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5698 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5699 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5700 } break;
5701 default: break;
5702 }
5703 return ret;
5704 }
5705 },
5706 {
5707 VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
__anon3431b75217902() 5708 [](VkBaseOutStructure* p) { (void)p;
5709 switch (p->sType) {
5710 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5711 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5712 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5713 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5714 } break;
5715 default: break;
5716 }
5717 },
__anon3431b75217a02() 5718 [](VkBaseOutStructure* p) -> bool { (void)p;
5719 bool ret = true;
5720 switch (p->sType) {
5721 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5722 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5723 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5724 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5725 } break;
5726 default: break;
5727 }
5728 return ret;
5729 }
5730 },
5731 {
5732 VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
__anon3431b75217b02() 5733 [](VkBaseOutStructure* p) { (void)p;
5734 switch (p->sType) {
5735 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5736 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5737 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5738 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5739 } break;
5740 default: break;
5741 }
5742 },
__anon3431b75217c02() 5743 [](VkBaseOutStructure* p) -> bool { (void)p;
5744 bool ret = true;
5745 switch (p->sType) {
5746 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5747 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5748 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5749 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5750 } break;
5751 default: break;
5752 }
5753 return ret;
5754 }
5755 },
5756 {
5757 VK_FORMAT_R16G16B16A16_SFLOAT,
__anon3431b75217d02() 5758 [](VkBaseOutStructure* p) { (void)p;
5759 switch (p->sType) {
5760 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5761 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5762 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
5763 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5764 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5765 } break;
5766 default: break;
5767 }
5768 },
__anon3431b75217e02() 5769 [](VkBaseOutStructure* p) -> bool { (void)p;
5770 bool ret = true;
5771 switch (p->sType) {
5772 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5773 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5774 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
5775 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5776 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5777 } break;
5778 default: break;
5779 }
5780 return ret;
5781 }
5782 },
5783 {
5784 VK_FORMAT_R16G16B16A16_SINT,
__anon3431b75217f02() 5785 [](VkBaseOutStructure* p) { (void)p;
5786 switch (p->sType) {
5787 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5788 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5789 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
5790 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5791 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5792 } break;
5793 default: break;
5794 }
5795 },
__anon3431b75218002() 5796 [](VkBaseOutStructure* p) -> bool { (void)p;
5797 bool ret = true;
5798 switch (p->sType) {
5799 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5800 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5801 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
5802 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5803 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5804 } break;
5805 default: break;
5806 }
5807 return ret;
5808 }
5809 },
5810 {
5811 VK_FORMAT_R16G16B16A16_SNORM,
__anon3431b75218102() 5812 [](VkBaseOutStructure* p) { (void)p;
5813 switch (p->sType) {
5814 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5815 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5816 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
5817 } break;
5818 default: break;
5819 }
5820 },
__anon3431b75218202() 5821 [](VkBaseOutStructure* p) -> bool { (void)p;
5822 bool ret = true;
5823 switch (p->sType) {
5824 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5825 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5826 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
5827 } break;
5828 default: break;
5829 }
5830 return ret;
5831 }
5832 },
5833 {
5834 VK_FORMAT_R16G16B16A16_UINT,
__anon3431b75218302() 5835 [](VkBaseOutStructure* p) { (void)p;
5836 switch (p->sType) {
5837 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5838 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5839 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
5840 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5841 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5842 } break;
5843 default: break;
5844 }
5845 },
__anon3431b75218402() 5846 [](VkBaseOutStructure* p) -> bool { (void)p;
5847 bool ret = true;
5848 switch (p->sType) {
5849 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5850 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5851 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
5852 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5853 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5854 } break;
5855 default: break;
5856 }
5857 return ret;
5858 }
5859 },
5860 {
5861 VK_FORMAT_R16G16_SFLOAT,
__anon3431b75218502() 5862 [](VkBaseOutStructure* p) { (void)p;
5863 switch (p->sType) {
5864 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5865 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5866 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
5867 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5868 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5869 } break;
5870 default: break;
5871 }
5872 },
__anon3431b75218602() 5873 [](VkBaseOutStructure* p) -> bool { (void)p;
5874 bool ret = true;
5875 switch (p->sType) {
5876 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5877 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5878 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
5879 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5880 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5881 } break;
5882 default: break;
5883 }
5884 return ret;
5885 }
5886 },
5887 {
5888 VK_FORMAT_R16G16_SINT,
__anon3431b75218702() 5889 [](VkBaseOutStructure* p) { (void)p;
5890 switch (p->sType) {
5891 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5892 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5893 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
5894 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5895 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5896 } break;
5897 default: break;
5898 }
5899 },
__anon3431b75218802() 5900 [](VkBaseOutStructure* p) -> bool { (void)p;
5901 bool ret = true;
5902 switch (p->sType) {
5903 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5904 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5905 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
5906 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5907 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5908 } break;
5909 default: break;
5910 }
5911 return ret;
5912 }
5913 },
5914 {
5915 VK_FORMAT_R16G16_SNORM,
__anon3431b75218902() 5916 [](VkBaseOutStructure* p) { (void)p;
5917 switch (p->sType) {
5918 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5919 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5920 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
5921 } break;
5922 default: break;
5923 }
5924 },
__anon3431b75218a02() 5925 [](VkBaseOutStructure* p) -> bool { (void)p;
5926 bool ret = true;
5927 switch (p->sType) {
5928 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5929 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5930 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
5931 } break;
5932 default: break;
5933 }
5934 return ret;
5935 }
5936 },
5937 {
5938 VK_FORMAT_R16G16_UINT,
__anon3431b75218b02() 5939 [](VkBaseOutStructure* p) { (void)p;
5940 switch (p->sType) {
5941 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5942 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5943 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5944 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5945 } break;
5946 default: break;
5947 }
5948 },
__anon3431b75218c02() 5949 [](VkBaseOutStructure* p) -> bool { (void)p;
5950 bool ret = true;
5951 switch (p->sType) {
5952 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5953 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5954 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5955 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5956 } break;
5957 default: break;
5958 }
5959 return ret;
5960 }
5961 },
5962 {
5963 VK_FORMAT_R16_SFLOAT,
__anon3431b75218d02() 5964 [](VkBaseOutStructure* p) { (void)p;
5965 switch (p->sType) {
5966 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5967 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5968 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
5969 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5970 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5971 } break;
5972 default: break;
5973 }
5974 },
__anon3431b75218e02() 5975 [](VkBaseOutStructure* p) -> bool { (void)p;
5976 bool ret = true;
5977 switch (p->sType) {
5978 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5979 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5980 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
5981 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5982 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
5983 } break;
5984 default: break;
5985 }
5986 return ret;
5987 }
5988 },
5989 {
5990 VK_FORMAT_R16_SINT,
__anon3431b75218f02() 5991 [](VkBaseOutStructure* p) { (void)p;
5992 switch (p->sType) {
5993 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
5994 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
5995 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
5996 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5997 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
5998 } break;
5999 default: break;
6000 }
6001 },
__anon3431b75219002() 6002 [](VkBaseOutStructure* p) -> bool { (void)p;
6003 bool ret = true;
6004 switch (p->sType) {
6005 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6006 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6007 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
6008 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6009 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6010 } break;
6011 default: break;
6012 }
6013 return ret;
6014 }
6015 },
6016 {
6017 VK_FORMAT_R16_SNORM,
__anon3431b75219102() 6018 [](VkBaseOutStructure* p) { (void)p;
6019 switch (p->sType) {
6020 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6021 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6022 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
6023 } break;
6024 default: break;
6025 }
6026 },
__anon3431b75219202() 6027 [](VkBaseOutStructure* p) -> bool { (void)p;
6028 bool ret = true;
6029 switch (p->sType) {
6030 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6031 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6032 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
6033 } break;
6034 default: break;
6035 }
6036 return ret;
6037 }
6038 },
6039 {
6040 VK_FORMAT_R16_UINT,
__anon3431b75219302() 6041 [](VkBaseOutStructure* p) { (void)p;
6042 switch (p->sType) {
6043 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6044 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6045 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
6046 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6047 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6048 } break;
6049 default: break;
6050 }
6051 },
__anon3431b75219402() 6052 [](VkBaseOutStructure* p) -> bool { (void)p;
6053 bool ret = true;
6054 switch (p->sType) {
6055 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6056 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6057 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
6058 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6059 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6060 } break;
6061 default: break;
6062 }
6063 return ret;
6064 }
6065 },
6066 {
6067 VK_FORMAT_R16_UNORM,
__anon3431b75219502() 6068 [](VkBaseOutStructure* p) { (void)p;
6069 switch (p->sType) {
6070 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6071 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6072 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
6073 } break;
6074 default: break;
6075 }
6076 },
__anon3431b75219602() 6077 [](VkBaseOutStructure* p) -> bool { (void)p;
6078 bool ret = true;
6079 switch (p->sType) {
6080 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6081 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6082 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
6083 } break;
6084 default: break;
6085 }
6086 return ret;
6087 }
6088 },
6089 {
6090 VK_FORMAT_R32G32B32A32_SFLOAT,
__anon3431b75219702() 6091 [](VkBaseOutStructure* p) { (void)p;
6092 switch (p->sType) {
6093 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6094 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6095 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6096 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6097 } break;
6098 default: break;
6099 }
6100 },
__anon3431b75219802() 6101 [](VkBaseOutStructure* p) -> bool { (void)p;
6102 bool ret = true;
6103 switch (p->sType) {
6104 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6105 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6106 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6107 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6108 } break;
6109 default: break;
6110 }
6111 return ret;
6112 }
6113 },
6114 {
6115 VK_FORMAT_R32G32B32A32_SINT,
__anon3431b75219902() 6116 [](VkBaseOutStructure* p) { (void)p;
6117 switch (p->sType) {
6118 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6119 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6120 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6121 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6122 } break;
6123 default: break;
6124 }
6125 },
__anon3431b75219a02() 6126 [](VkBaseOutStructure* p) -> bool { (void)p;
6127 bool ret = true;
6128 switch (p->sType) {
6129 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6130 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6131 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6132 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6133 } break;
6134 default: break;
6135 }
6136 return ret;
6137 }
6138 },
6139 {
6140 VK_FORMAT_R32G32B32A32_UINT,
__anon3431b75219b02() 6141 [](VkBaseOutStructure* p) { (void)p;
6142 switch (p->sType) {
6143 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6144 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6145 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6146 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6147 } break;
6148 default: break;
6149 }
6150 },
__anon3431b75219c02() 6151 [](VkBaseOutStructure* p) -> bool { (void)p;
6152 bool ret = true;
6153 switch (p->sType) {
6154 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6155 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6156 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6157 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6158 } break;
6159 default: break;
6160 }
6161 return ret;
6162 }
6163 },
6164 {
6165 VK_FORMAT_R32G32_SFLOAT,
__anon3431b75219d02() 6166 [](VkBaseOutStructure* p) { (void)p;
6167 switch (p->sType) {
6168 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6169 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6170 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
6171 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6172 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6173 } break;
6174 default: break;
6175 }
6176 },
__anon3431b75219e02() 6177 [](VkBaseOutStructure* p) -> bool { (void)p;
6178 bool ret = true;
6179 switch (p->sType) {
6180 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6181 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6182 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
6183 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6184 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6185 } break;
6186 default: break;
6187 }
6188 return ret;
6189 }
6190 },
6191 {
6192 VK_FORMAT_R32G32_SINT,
__anon3431b75219f02() 6193 [](VkBaseOutStructure* p) { (void)p;
6194 switch (p->sType) {
6195 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6196 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6197 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
6198 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6199 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6200 } break;
6201 default: break;
6202 }
6203 },
__anon3431b7521a002() 6204 [](VkBaseOutStructure* p) -> bool { (void)p;
6205 bool ret = true;
6206 switch (p->sType) {
6207 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6208 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6209 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
6210 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6211 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6212 } break;
6213 default: break;
6214 }
6215 return ret;
6216 }
6217 },
6218 {
6219 VK_FORMAT_R32G32_UINT,
__anon3431b7521a102() 6220 [](VkBaseOutStructure* p) { (void)p;
6221 switch (p->sType) {
6222 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6223 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6224 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
6225 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6226 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6227 } break;
6228 default: break;
6229 }
6230 },
__anon3431b7521a202() 6231 [](VkBaseOutStructure* p) -> bool { (void)p;
6232 bool ret = true;
6233 switch (p->sType) {
6234 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6235 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6236 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
6237 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6238 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6239 } break;
6240 default: break;
6241 }
6242 return ret;
6243 }
6244 },
6245 {
6246 VK_FORMAT_R32_SFLOAT,
__anon3431b7521a302() 6247 [](VkBaseOutStructure* p) { (void)p;
6248 switch (p->sType) {
6249 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6250 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6251 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
6252 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6253 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6254 } break;
6255 default: break;
6256 }
6257 },
__anon3431b7521a402() 6258 [](VkBaseOutStructure* p) -> bool { (void)p;
6259 bool ret = true;
6260 switch (p->sType) {
6261 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6262 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6263 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
6264 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6265 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6266 } break;
6267 default: break;
6268 }
6269 return ret;
6270 }
6271 },
6272 {
6273 VK_FORMAT_R32_SINT,
__anon3431b7521a502() 6274 [](VkBaseOutStructure* p) { (void)p;
6275 switch (p->sType) {
6276 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6277 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6278 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
6279 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6280 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6281 } break;
6282 default: break;
6283 }
6284 },
__anon3431b7521a602() 6285 [](VkBaseOutStructure* p) -> bool { (void)p;
6286 bool ret = true;
6287 switch (p->sType) {
6288 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6289 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6290 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
6291 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6292 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6293 } break;
6294 default: break;
6295 }
6296 return ret;
6297 }
6298 },
6299 {
6300 VK_FORMAT_R32_UINT,
__anon3431b7521a702() 6301 [](VkBaseOutStructure* p) { (void)p;
6302 switch (p->sType) {
6303 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6304 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6305 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
6306 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6307 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6308 } break;
6309 default: break;
6310 }
6311 },
__anon3431b7521a802() 6312 [](VkBaseOutStructure* p) -> bool { (void)p;
6313 bool ret = true;
6314 switch (p->sType) {
6315 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6316 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6317 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
6318 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6319 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6320 } break;
6321 default: break;
6322 }
6323 return ret;
6324 }
6325 },
6326 {
6327 VK_FORMAT_R5G6B5_UNORM_PACK16,
__anon3431b7521a902() 6328 [](VkBaseOutStructure* p) { (void)p;
6329 switch (p->sType) {
6330 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6331 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6332 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6333 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6334 } break;
6335 default: break;
6336 }
6337 },
__anon3431b7521aa02() 6338 [](VkBaseOutStructure* p) -> bool { (void)p;
6339 bool ret = true;
6340 switch (p->sType) {
6341 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6342 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6343 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6344 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6345 } break;
6346 default: break;
6347 }
6348 return ret;
6349 }
6350 },
6351 {
6352 VK_FORMAT_R8G8B8A8_SINT,
__anon3431b7521ab02() 6353 [](VkBaseOutStructure* p) { (void)p;
6354 switch (p->sType) {
6355 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6356 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6357 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
6358 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6359 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6360 } break;
6361 default: break;
6362 }
6363 },
__anon3431b7521ac02() 6364 [](VkBaseOutStructure* p) -> bool { (void)p;
6365 bool ret = true;
6366 switch (p->sType) {
6367 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6368 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6369 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
6370 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6371 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6372 } break;
6373 default: break;
6374 }
6375 return ret;
6376 }
6377 },
6378 {
6379 VK_FORMAT_R8G8B8A8_SNORM,
__anon3431b7521ad02() 6380 [](VkBaseOutStructure* p) { (void)p;
6381 switch (p->sType) {
6382 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6383 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6384 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
6385 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6386 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6387 } break;
6388 default: break;
6389 }
6390 },
__anon3431b7521ae02() 6391 [](VkBaseOutStructure* p) -> bool { (void)p;
6392 bool ret = true;
6393 switch (p->sType) {
6394 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6395 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6396 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
6397 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6398 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6399 } break;
6400 default: break;
6401 }
6402 return ret;
6403 }
6404 },
6405 {
6406 VK_FORMAT_R8G8B8A8_SRGB,
__anon3431b7521af02() 6407 [](VkBaseOutStructure* p) { (void)p;
6408 switch (p->sType) {
6409 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6410 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6411 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6412 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6413 } break;
6414 default: break;
6415 }
6416 },
__anon3431b7521b002() 6417 [](VkBaseOutStructure* p) -> bool { (void)p;
6418 bool ret = true;
6419 switch (p->sType) {
6420 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6421 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6422 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6423 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6424 } break;
6425 default: break;
6426 }
6427 return ret;
6428 }
6429 },
6430 {
6431 VK_FORMAT_R8G8B8A8_UINT,
__anon3431b7521b102() 6432 [](VkBaseOutStructure* p) { (void)p;
6433 switch (p->sType) {
6434 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6435 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6436 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
6437 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6438 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6439 } break;
6440 default: break;
6441 }
6442 },
__anon3431b7521b202() 6443 [](VkBaseOutStructure* p) -> bool { (void)p;
6444 bool ret = true;
6445 switch (p->sType) {
6446 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6447 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6448 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
6449 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6450 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6451 } break;
6452 default: break;
6453 }
6454 return ret;
6455 }
6456 },
6457 {
6458 VK_FORMAT_R8G8B8A8_UNORM,
__anon3431b7521b302() 6459 [](VkBaseOutStructure* p) { (void)p;
6460 switch (p->sType) {
6461 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6462 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6463 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
6464 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6465 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6466 } break;
6467 default: break;
6468 }
6469 },
__anon3431b7521b402() 6470 [](VkBaseOutStructure* p) -> bool { (void)p;
6471 bool ret = true;
6472 switch (p->sType) {
6473 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6474 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6475 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
6476 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6477 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6478 } break;
6479 default: break;
6480 }
6481 return ret;
6482 }
6483 },
6484 {
6485 VK_FORMAT_R8G8_SINT,
__anon3431b7521b502() 6486 [](VkBaseOutStructure* p) { (void)p;
6487 switch (p->sType) {
6488 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6489 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6490 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
6491 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6492 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6493 } break;
6494 default: break;
6495 }
6496 },
__anon3431b7521b602() 6497 [](VkBaseOutStructure* p) -> bool { (void)p;
6498 bool ret = true;
6499 switch (p->sType) {
6500 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6501 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6502 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
6503 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6504 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6505 } break;
6506 default: break;
6507 }
6508 return ret;
6509 }
6510 },
6511 {
6512 VK_FORMAT_R8G8_SNORM,
__anon3431b7521b702() 6513 [](VkBaseOutStructure* p) { (void)p;
6514 switch (p->sType) {
6515 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6516 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6517 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
6518 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6519 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6520 } break;
6521 default: break;
6522 }
6523 },
__anon3431b7521b802() 6524 [](VkBaseOutStructure* p) -> bool { (void)p;
6525 bool ret = true;
6526 switch (p->sType) {
6527 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6528 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6529 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
6530 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6531 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6532 } break;
6533 default: break;
6534 }
6535 return ret;
6536 }
6537 },
6538 {
6539 VK_FORMAT_R8G8_UINT,
__anon3431b7521b902() 6540 [](VkBaseOutStructure* p) { (void)p;
6541 switch (p->sType) {
6542 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6543 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6544 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
6545 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6546 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6547 } break;
6548 default: break;
6549 }
6550 },
__anon3431b7521ba02() 6551 [](VkBaseOutStructure* p) -> bool { (void)p;
6552 bool ret = true;
6553 switch (p->sType) {
6554 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6555 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6556 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
6557 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6558 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6559 } break;
6560 default: break;
6561 }
6562 return ret;
6563 }
6564 },
6565 {
6566 VK_FORMAT_R8G8_UNORM,
__anon3431b7521bb02() 6567 [](VkBaseOutStructure* p) { (void)p;
6568 switch (p->sType) {
6569 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6570 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6571 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
6572 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6573 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6574 } break;
6575 default: break;
6576 }
6577 },
__anon3431b7521bc02() 6578 [](VkBaseOutStructure* p) -> bool { (void)p;
6579 bool ret = true;
6580 switch (p->sType) {
6581 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6582 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6583 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
6584 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6585 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6586 } break;
6587 default: break;
6588 }
6589 return ret;
6590 }
6591 },
6592 {
6593 VK_FORMAT_R8_SINT,
__anon3431b7521bd02() 6594 [](VkBaseOutStructure* p) { (void)p;
6595 switch (p->sType) {
6596 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6597 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6598 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
6599 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6600 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6601 } break;
6602 default: break;
6603 }
6604 },
__anon3431b7521be02() 6605 [](VkBaseOutStructure* p) -> bool { (void)p;
6606 bool ret = true;
6607 switch (p->sType) {
6608 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6609 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6610 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
6611 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6612 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6613 } break;
6614 default: break;
6615 }
6616 return ret;
6617 }
6618 },
6619 {
6620 VK_FORMAT_R8_SNORM,
__anon3431b7521bf02() 6621 [](VkBaseOutStructure* p) { (void)p;
6622 switch (p->sType) {
6623 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6624 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6625 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
6626 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6627 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6628 } break;
6629 default: break;
6630 }
6631 },
__anon3431b7521c002() 6632 [](VkBaseOutStructure* p) -> bool { (void)p;
6633 bool ret = true;
6634 switch (p->sType) {
6635 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6636 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6637 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
6638 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6639 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6640 } break;
6641 default: break;
6642 }
6643 return ret;
6644 }
6645 },
6646 {
6647 VK_FORMAT_R8_UINT,
__anon3431b7521c102() 6648 [](VkBaseOutStructure* p) { (void)p;
6649 switch (p->sType) {
6650 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6651 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6652 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
6653 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6654 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6655 } break;
6656 default: break;
6657 }
6658 },
__anon3431b7521c202() 6659 [](VkBaseOutStructure* p) -> bool { (void)p;
6660 bool ret = true;
6661 switch (p->sType) {
6662 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6663 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6664 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
6665 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6666 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6667 } break;
6668 default: break;
6669 }
6670 return ret;
6671 }
6672 },
6673 {
6674 VK_FORMAT_R8_UNORM,
__anon3431b7521c302() 6675 [](VkBaseOutStructure* p) { (void)p;
6676 switch (p->sType) {
6677 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6678 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6679 s->formatProperties.bufferFeatures |= (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
6680 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6681 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
6682 } break;
6683 default: break;
6684 }
6685 },
__anon3431b7521c402() 6686 [](VkBaseOutStructure* p) -> bool { (void)p;
6687 bool ret = true;
6688 switch (p->sType) {
6689 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
6690 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
6691 ret = ret && (vpCheckFlags(s->formatProperties.bufferFeatures, (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)));
6692 ret = ret && (vpCheckFlags(s->formatProperties.linearTilingFeatures, (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6693 ret = ret && (vpCheckFlags(s->formatProperties.optimalTilingFeatures, (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)));
6694 } break;
6695 default: break;
6696 }
6697 return ret;
6698 }
6699 },
6700 };
6701
6702 static const VpStructChainerDesc chainerDesc = {
__anon3431b7521c502() 6703 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
6704 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(nullptr));
6705 pfnCb(p, pUser);
6706 },
__anon3431b7521c602() 6707 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
6708 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(nullptr));
6709 pfnCb(p, pUser);
6710 },
__anon3431b7521c702() 6711 [](uint32_t count, VkBaseOutStructure* p, void* pUser, PFN_vpStructArrayChainerCb pfnCb) {
6712 pfnCb(count, p, pUser);
6713 },
__anon3431b7521c802() 6714 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
6715 VkFormatProperties3KHR formatProperties3KHR{ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr };
6716 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(&formatProperties3KHR));
6717 pfnCb(p, pUser);
6718 },
6719 };
6720 } // namespace baseline
6721 } // namespace blocks
6722 } // namespace VP_ANDROID_BASELINE_2021_CPU_ONLY
6723 #endif // VP_ANDROID_baseline_2021_cpu_only
6724
6725 #ifdef VP_ANDROID_baseline_2022
6726 namespace VP_ANDROID_BASELINE_2022 {
6727
6728 static const VkStructureType featureStructTypes[] = {
6729 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR,
6730 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES,
6731 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES,
6732 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
6733 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
6734 };
6735
6736 static const VkStructureType propertyStructTypes[] = {
6737 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR,
6738 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES,
6739 };
6740
6741 static const VkStructureType formatStructTypes[] = {
6742 VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR,
6743 VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR,
6744 };
6745
6746 static const VkExtensionProperties instanceExtensions[] = {
6747 VkExtensionProperties{ VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME, 1 },
6748 VkExtensionProperties{ VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, 1 },
6749 VkExtensionProperties{ VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME, 1 },
6750 VkExtensionProperties{ VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, 1 },
6751 VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME, 1 },
6752 VkExtensionProperties{ VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, 1 },
6753 VkExtensionProperties{ VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, 1 },
6754 VkExtensionProperties{ VK_KHR_SURFACE_EXTENSION_NAME, 1 },
6755 };
6756
6757 static const VkExtensionProperties deviceExtensions[] = {
6758 VkExtensionProperties{ VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME, 1 },
6759 VkExtensionProperties{ VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME, 1 },
6760 VkExtensionProperties{ VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME, 1 },
6761 VkExtensionProperties{ VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME, 1 },
6762 VkExtensionProperties{ VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, 1 },
6763 VkExtensionProperties{ VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME, 1 },
6764 VkExtensionProperties{ VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME, 1 },
6765 VkExtensionProperties{ VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME, 1 },
6766 VkExtensionProperties{ VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME, 1 },
6767 VkExtensionProperties{ VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, 1 },
6768 VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME, 1 },
6769 VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME, 1 },
6770 VkExtensionProperties{ VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, 1 },
6771 VkExtensionProperties{ VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME, 1 },
6772 VkExtensionProperties{ VK_KHR_MAINTENANCE_1_EXTENSION_NAME, 1 },
6773 VkExtensionProperties{ VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME, 1 },
6774 VkExtensionProperties{ VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME, 1 },
6775 VkExtensionProperties{ VK_KHR_SWAPCHAIN_EXTENSION_NAME, 1 },
6776 VkExtensionProperties{ VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME, 1 },
6777 };
6778
6779 static const VpFeatureDesc featureDesc = {
__anon3431b7521c902() 6780 [](VkBaseOutStructure* p) { (void)p;
6781 switch (p->sType) {
6782 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: {
6783 VkPhysicalDeviceFeatures2KHR* s = static_cast<VkPhysicalDeviceFeatures2KHR*>(static_cast<void*>(p));
6784 s->features.depthBiasClamp = VK_TRUE;
6785 s->features.fragmentStoresAndAtomics = VK_TRUE;
6786 s->features.fullDrawIndexUint32 = VK_TRUE;
6787 s->features.imageCubeArray = VK_TRUE;
6788 s->features.independentBlend = VK_TRUE;
6789 s->features.largePoints = VK_TRUE;
6790 s->features.robustBufferAccess = VK_TRUE;
6791 s->features.sampleRateShading = VK_TRUE;
6792 s->features.shaderInt16 = VK_TRUE;
6793 s->features.shaderSampledImageArrayDynamicIndexing = VK_TRUE;
6794 s->features.shaderStorageBufferArrayDynamicIndexing = VK_TRUE;
6795 s->features.shaderStorageImageArrayDynamicIndexing = VK_TRUE;
6796 s->features.shaderUniformBufferArrayDynamicIndexing = VK_TRUE;
6797 s->features.textureCompressionASTC_LDR = VK_TRUE;
6798 s->features.textureCompressionETC2 = VK_TRUE;
6799 } break;
6800 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: {
6801 VkPhysicalDeviceMultiviewFeatures* s = static_cast<VkPhysicalDeviceMultiviewFeatures*>(static_cast<void*>(p));
6802 s->multiview = VK_TRUE;
6803 } break;
6804 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: {
6805 VkPhysicalDeviceSamplerYcbcrConversionFeatures* s = static_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(static_cast<void*>(p));
6806 s->samplerYcbcrConversion = VK_TRUE;
6807 } break;
6808 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: {
6809 VkPhysicalDeviceShaderDrawParametersFeatures* s = static_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(static_cast<void*>(p));
6810 s->shaderDrawParameters = VK_TRUE;
6811 } break;
6812 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: {
6813 VkPhysicalDeviceVariablePointersFeatures* s = static_cast<VkPhysicalDeviceVariablePointersFeatures*>(static_cast<void*>(p));
6814 s->variablePointers = VK_TRUE;
6815 s->variablePointersStorageBuffer = VK_TRUE;
6816 } break;
6817 default: break;
6818 }
6819 },
__anon3431b7521ca02() 6820 [](VkBaseOutStructure* p) -> bool { (void)p;
6821 bool ret = true;
6822 switch (p->sType) {
6823 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: {
6824 VkPhysicalDeviceFeatures2KHR* s = static_cast<VkPhysicalDeviceFeatures2KHR*>(static_cast<void*>(p));
6825 ret = ret && (s->features.depthBiasClamp == VK_TRUE);
6826 ret = ret && (s->features.fragmentStoresAndAtomics == VK_TRUE);
6827 ret = ret && (s->features.fullDrawIndexUint32 == VK_TRUE);
6828 ret = ret && (s->features.imageCubeArray == VK_TRUE);
6829 ret = ret && (s->features.independentBlend == VK_TRUE);
6830 ret = ret && (s->features.largePoints == VK_TRUE);
6831 ret = ret && (s->features.robustBufferAccess == VK_TRUE);
6832 ret = ret && (s->features.sampleRateShading == VK_TRUE);
6833 ret = ret && (s->features.shaderInt16 == VK_TRUE);
6834 ret = ret && (s->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE);
6835 ret = ret && (s->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE);
6836 ret = ret && (s->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE);
6837 ret = ret && (s->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE);
6838 ret = ret && (s->features.textureCompressionASTC_LDR == VK_TRUE);
6839 ret = ret && (s->features.textureCompressionETC2 == VK_TRUE);
6840 } break;
6841 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: {
6842 VkPhysicalDeviceMultiviewFeatures* s = static_cast<VkPhysicalDeviceMultiviewFeatures*>(static_cast<void*>(p));
6843 ret = ret && (s->multiview == VK_TRUE);
6844 } break;
6845 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: {
6846 VkPhysicalDeviceSamplerYcbcrConversionFeatures* s = static_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(static_cast<void*>(p));
6847 ret = ret && (s->samplerYcbcrConversion == VK_TRUE);
6848 } break;
6849 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: {
6850 VkPhysicalDeviceShaderDrawParametersFeatures* s = static_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(static_cast<void*>(p));
6851 ret = ret && (s->shaderDrawParameters == VK_TRUE);
6852 } break;
6853 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: {
6854 VkPhysicalDeviceVariablePointersFeatures* s = static_cast<VkPhysicalDeviceVariablePointersFeatures*>(static_cast<void*>(p));
6855 ret = ret && (s->variablePointers == VK_TRUE);
6856 ret = ret && (s->variablePointersStorageBuffer == VK_TRUE);
6857 } break;
6858 default: break;
6859 }
6860 return ret;
6861 }
6862 };
6863
6864 static const VpPropertyDesc propertyDesc = {
__anon3431b7521cb02() 6865 [](VkBaseOutStructure* p) { (void)p;
6866 },
__anon3431b7521cc02() 6867 [](VkBaseOutStructure* p) -> bool { (void)p;
6868 bool ret = true;
6869 return ret;
6870 }
6871 };
6872
6873 static const VpStructChainerDesc chainerDesc = {
__anon3431b7521cd02() 6874 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
6875 VkPhysicalDeviceMultiviewFeatures physicalDeviceMultiviewFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, nullptr };
6876 VkPhysicalDeviceSamplerYcbcrConversionFeatures physicalDeviceSamplerYcbcrConversionFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, &physicalDeviceMultiviewFeatures };
6877 VkPhysicalDeviceShaderDrawParametersFeatures physicalDeviceShaderDrawParametersFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, &physicalDeviceSamplerYcbcrConversionFeatures };
6878 VkPhysicalDeviceVariablePointersFeatures physicalDeviceVariablePointersFeatures{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, &physicalDeviceShaderDrawParametersFeatures };
6879 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(&physicalDeviceVariablePointersFeatures));
6880 pfnCb(p, pUser);
6881 },
__anon3431b7521ce02() 6882 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
6883 VkPhysicalDeviceMultiviewProperties physicalDeviceMultiviewProperties{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, nullptr };
6884 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(&physicalDeviceMultiviewProperties));
6885 pfnCb(p, pUser);
6886 },
__anon3431b7521cf02() 6887 [](uint32_t count, VkBaseOutStructure* p, void* pUser, PFN_vpStructArrayChainerCb pfnCb) {
6888 pfnCb(count, p, pUser);
6889 },
__anon3431b7521d002() 6890 [](VkBaseOutStructure* p, void* pUser, PFN_vpStructChainerCb pfnCb) {
6891 VkFormatProperties3KHR formatProperties3KHR{ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, nullptr };
6892 p->pNext = static_cast<VkBaseOutStructure*>(static_cast<void*>(&formatProperties3KHR));
6893 pfnCb(p, pUser);
6894 },
6895 };
6896
6897 namespace blocks {
6898 namespace baseline {
6899
6900 static const VkExtensionProperties instanceExtensions[] = {
6901 VkExtensionProperties{ VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME, 1 },
6902 VkExtensionProperties{ VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, 1 },
6903 VkExtensionProperties{ VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME, 1 },
6904 VkExtensionProperties{ VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, 1 },
6905 VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME, 1 },
6906 VkExtensionProperties{ VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, 1 },
6907 VkExtensionProperties{ VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, 1 },
6908 VkExtensionProperties{ VK_KHR_SURFACE_EXTENSION_NAME, 1 },
6909 };
6910
6911 static const VkExtensionProperties deviceExtensions[] = {
6912 VkExtensionProperties{ VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME, 1 },
6913 VkExtensionProperties{ VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME, 1 },
6914 VkExtensionProperties{ VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME, 1 },
6915 VkExtensionProperties{ VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME, 1 },
6916 VkExtensionProperties{ VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, 1 },
6917 VkExtensionProperties{ VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME, 1 },
6918 VkExtensionProperties{ VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME, 1 },
6919 VkExtensionProperties{ VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME, 1 },
6920 VkExtensionProperties{ VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME, 1 },
6921 VkExtensionProperties{ VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, 1 },
6922 VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME, 1 },
6923 VkExtensionProperties{ VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME, 1 },
6924 VkExtensionProperties{ VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, 1 },
6925 VkExtensionProperties{ VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME, 1 },
6926 VkExtensionProperties{ VK_KHR_MAINTENANCE_1_EXTENSION_NAME, 1 },
6927 VkExtensionProperties{ VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME, 1 },
6928 VkExtensionProperties{ VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME, 1 },
6929 VkExtensionProperties{ VK_KHR_SWAPCHAIN_EXTENSION_NAME, 1 },
6930 VkExtensionProperties{ VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME, 1 },
6931 };
6932
6933 static const VpFeatureDesc featureDesc = {
__anon3431b7521d102() 6934 [](VkBaseOutStructure* p) { (void)p;
6935 switch (p->sType) {
6936 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: {
6937 VkPhysicalDeviceFeatures2KHR* s = static_cast<VkPhysicalDeviceFeatures2KHR*>(static_cast<void*>(p));
6938 s->features.depthBiasClamp = VK_TRUE;
6939 s->features.fragmentStoresAndAtomics = VK_TRUE;
6940 s->features.fullDrawIndexUint32 = VK_TRUE;
6941 s->features.imageCubeArray = VK_TRUE;
6942 s->features.independentBlend = VK_TRUE;
6943 s->features.largePoints = VK_TRUE;
6944 s->features.robustBufferAccess = VK_TRUE;
6945 s->features.sampleRateShading = VK_TRUE;
6946 s->features.shaderInt16 = VK_TRUE;
6947 s->features.shaderSampledImageArrayDynamicIndexing = VK_TRUE;
6948 s->features.shaderStorageBufferArrayDynamicIndexing = VK_TRUE;
6949 s->features.shaderStorageImageArrayDynamicIndexing = VK_TRUE;
6950 s->features.shaderUniformBufferArrayDynamicIndexing = VK_TRUE;
6951 s->features.textureCompressionASTC_LDR = VK_TRUE;
6952 s->features.textureCompressionETC2 = VK_TRUE;
6953 } break;
6954 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: {
6955 VkPhysicalDeviceMultiviewFeatures* s = static_cast<VkPhysicalDeviceMultiviewFeatures*>(static_cast<void*>(p));
6956 s->multiview = VK_TRUE;
6957 } break;
6958 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: {
6959 VkPhysicalDeviceSamplerYcbcrConversionFeatures* s = static_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(static_cast<void*>(p));
6960 s->samplerYcbcrConversion = VK_TRUE;
6961 } break;
6962 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: {
6963 VkPhysicalDeviceShaderDrawParametersFeatures* s = static_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(static_cast<void*>(p));
6964 s->shaderDrawParameters = VK_TRUE;
6965 } break;
6966 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: {
6967 VkPhysicalDeviceVariablePointersFeatures* s = static_cast<VkPhysicalDeviceVariablePointersFeatures*>(static_cast<void*>(p));
6968 s->variablePointers = VK_TRUE;
6969 s->variablePointersStorageBuffer = VK_TRUE;
6970 } break;
6971 default: break;
6972 }
6973 },
__anon3431b7521d202() 6974 [](VkBaseOutStructure* p) -> bool { (void)p;
6975 bool ret = true;
6976 switch (p->sType) {
6977 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: {
6978 VkPhysicalDeviceFeatures2KHR* s = static_cast<VkPhysicalDeviceFeatures2KHR*>(static_cast<void*>(p));
6979 ret = ret && (s->features.depthBiasClamp == VK_TRUE);
6980 ret = ret && (s->features.fragmentStoresAndAtomics == VK_TRUE);
6981 ret = ret && (s->features.fullDrawIndexUint32 == VK_TRUE);
6982 ret = ret && (s->features.imageCubeArray == VK_TRUE);
6983 ret = ret && (s->features.independentBlend == VK_TRUE);
6984 ret = ret && (s->features.largePoints == VK_TRUE);
6985 ret = ret && (s->features.robustBufferAccess == VK_TRUE);
6986 ret = ret && (s->features.sampleRateShading == VK_TRUE);
6987 ret = ret && (s->features.shaderInt16 == VK_TRUE);
6988 ret = ret && (s->features.shaderSampledImageArrayDynamicIndexing == VK_TRUE);
6989 ret = ret && (s->features.shaderStorageBufferArrayDynamicIndexing == VK_TRUE);
6990 ret = ret && (s->features.shaderStorageImageArrayDynamicIndexing == VK_TRUE);
6991 ret = ret && (s->features.shaderUniformBufferArrayDynamicIndexing == VK_TRUE);
6992 ret = ret && (s->features.textureCompressionASTC_LDR == VK_TRUE);
6993 ret = ret && (s->features.textureCompressionETC2 == VK_TRUE);
6994 } break;
6995 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: {
6996 VkPhysicalDeviceMultiviewFeatures* s = static_cast<VkPhysicalDeviceMultiviewFeatures*>(static_cast<void*>(p));
6997 ret = ret && (s->multiview == VK_TRUE);
6998 } break;
6999 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: {
7000 VkPhysicalDeviceSamplerYcbcrConversionFeatures* s = static_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(static_cast<void*>(p));
7001 ret = ret && (s->samplerYcbcrConversion == VK_TRUE);
7002 } break;
7003 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: {
7004 VkPhysicalDeviceShaderDrawParametersFeatures* s = static_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(static_cast<void*>(p));
7005 ret = ret && (s->shaderDrawParameters == VK_TRUE);
7006 } break;
7007 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: {
7008 VkPhysicalDeviceVariablePointersFeatures* s = static_cast<VkPhysicalDeviceVariablePointersFeatures*>(static_cast<void*>(p));
7009 ret = ret && (s->variablePointers == VK_TRUE);
7010 ret = ret && (s->variablePointersStorageBuffer == VK_TRUE);
7011 } break;
7012 default: break;
7013 }
7014 return ret;
7015 }
7016 };
7017
7018 static const VpPropertyDesc propertyDesc = {
__anon3431b7521d302() 7019 [](VkBaseOutStructure* p) { (void)p;
7020 switch (p->sType) {
7021 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: {
7022 VkPhysicalDeviceProperties2KHR* s = static_cast<VkPhysicalDeviceProperties2KHR*>(static_cast<void*>(p));
7023 s->properties.limits.discreteQueuePriorities = 2;
7024 s->properties.limits.framebufferColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT);
7025 s->properties.limits.framebufferDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT);
7026 s->properties.limits.framebufferNoAttachmentsSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT);
7027 s->properties.limits.framebufferStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT);
7028 s->properties.limits.maxBoundDescriptorSets = 4;
7029 s->properties.limits.maxColorAttachments = 4;
7030 s->properties.limits.maxComputeSharedMemorySize = 16384;
7031 s->properties.limits.maxComputeWorkGroupCount[0] = 65535;
7032 s->properties.limits.maxComputeWorkGroupCount[1] = 65535;
7033 s->properties.limits.maxComputeWorkGroupCount[2] = 65535;
7034 s->properties.limits.maxComputeWorkGroupInvocations = 128;
7035 s->properties.limits.maxComputeWorkGroupSize[0] = 128;
7036 s->properties.limits.maxComputeWorkGroupSize[1] = 128;
7037 s->properties.limits.maxComputeWorkGroupSize[2] = 64;
7038 s->properties.limits.maxDescriptorSetInputAttachments = 4;
7039 s->properties.limits.maxDescriptorSetSampledImages = 48;
7040 s->properties.limits.maxDescriptorSetSamplers = 48;
7041 s->properties.limits.maxDescriptorSetStorageBuffers = 24;
7042 s->properties.limits.maxDescriptorSetStorageBuffersDynamic = 4;
7043 s->properties.limits.maxDescriptorSetStorageImages = 12;
7044 s->properties.limits.maxDescriptorSetUniformBuffers = 36;
7045 s->properties.limits.maxDescriptorSetUniformBuffersDynamic = 8;
7046 s->properties.limits.maxDrawIndexedIndexValue = 4294967295;
7047 s->properties.limits.maxDrawIndirectCount = 1;
7048 s->properties.limits.maxFragmentCombinedOutputResources = 8;
7049 s->properties.limits.maxFragmentInputComponents = 64;
7050 s->properties.limits.maxFragmentOutputAttachments = 4;
7051 s->properties.limits.maxFramebufferHeight = 4096;
7052 s->properties.limits.maxFramebufferLayers = 256;
7053 s->properties.limits.maxFramebufferWidth = 4096;
7054 s->properties.limits.maxImageArrayLayers = 256;
7055 s->properties.limits.maxImageDimension1D = 4096;
7056 s->properties.limits.maxImageDimension2D = 4096;
7057 s->properties.limits.maxImageDimension3D = 512;
7058 s->properties.limits.maxImageDimensionCube = 4096;
7059 s->properties.limits.maxInterpolationOffset = 0.4375f;
7060 s->properties.limits.maxMemoryAllocationCount = 4096;
7061 s->properties.limits.maxPerStageDescriptorInputAttachments = 4;
7062 s->properties.limits.maxPerStageDescriptorSampledImages = 16;
7063 s->properties.limits.maxPerStageDescriptorSamplers = 16;
7064 s->properties.limits.maxPerStageDescriptorStorageBuffers = 4;
7065 s->properties.limits.maxPerStageDescriptorStorageImages = 4;
7066 s->properties.limits.maxPerStageDescriptorUniformBuffers = 12;
7067 s->properties.limits.maxPerStageResources = 44;
7068 s->properties.limits.maxPushConstantsSize = 128;
7069 s->properties.limits.maxSampleMaskWords = 1;
7070 s->properties.limits.maxSamplerAllocationCount = 4000;
7071 s->properties.limits.maxSamplerAnisotropy = 1.0f;
7072 s->properties.limits.maxSamplerLodBias = 2.0f;
7073 s->properties.limits.maxStorageBufferRange = 134217728;
7074 s->properties.limits.maxTexelBufferElements = 65536;
7075 s->properties.limits.maxTexelOffset = 7;
7076 s->properties.limits.maxUniformBufferRange = 16384;
7077 s->properties.limits.maxVertexInputAttributeOffset = 2047;
7078 s->properties.limits.maxVertexInputAttributes = 16;
7079 s->properties.limits.maxVertexInputBindingStride = 2048;
7080 s->properties.limits.maxVertexInputBindings = 16;
7081 s->properties.limits.maxVertexOutputComponents = 64;
7082 s->properties.limits.maxViewportDimensions[0] = 4096;
7083 s->properties.limits.maxViewportDimensions[1] = 4096;
7084 s->properties.limits.maxViewports = 1;
7085 s->properties.limits.minInterpolationOffset = -0.5f;
7086 s->properties.limits.minMemoryMapAlignment = 4096;
7087 s->properties.limits.minStorageBufferOffsetAlignment = 256;
7088 s->properties.limits.minTexelBufferOffsetAlignment = 256;
7089 s->properties.limits.minTexelOffset = -8;
7090 s->properties.limits.minUniformBufferOffsetAlignment = 256;
7091 s->properties.limits.mipmapPrecisionBits = 4;
7092 s->properties.limits.pointSizeGranularity = 1;
7093 s->properties.limits.pointSizeRange[0] = 1.0f;
7094 s->properties.limits.pointSizeRange[1] = 511;
7095 s->properties.limits.sampledImageColorSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT);
7096 s->properties.limits.sampledImageDepthSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT);
7097 s->properties.limits.sampledImageIntegerSampleCounts |= (VK_SAMPLE_COUNT_1_BIT);
7098 s->properties.limits.sampledImageStencilSampleCounts |= (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT);
7099 s->properties.limits.standardSampleLocations = VK_TRUE;
7100 s->properties.limits.storageImageSampleCounts |= (VK_SAMPLE_COUNT_1_BIT);
7101 s->properties.limits.subPixelInterpolationOffsetBits = 4;
7102 s->properties.limits.subPixelPrecisionBits = 4;
7103 s->properties.limits.subTexelPrecisionBits = 4;
7104 s->properties.limits.viewportBoundsRange[0] = -8192;
7105 s->properties.limits.viewportBoundsRange[1] = 8191;
7106 } break;
7107 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: {
7108 VkPhysicalDeviceMultiviewProperties* s = static_cast<VkPhysicalDeviceMultiviewProperties*>(static_cast<void*>(p));
7109 s->maxMultiviewInstanceIndex = 134217727;
7110 s->maxMultiviewViewCount = 6;
7111 } break;
7112 default: break;
7113 }
7114 },
__anon3431b7521d402() 7115 [](VkBaseOutStructure* p) -> bool { (void)p;
7116 bool ret = true;
7117 switch (p->sType) {
7118 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: {
7119 VkPhysicalDeviceProperties2KHR* s = static_cast<VkPhysicalDeviceProperties2KHR*>(static_cast<void*>(p));
7120 ret = ret && (s->properties.limits.discreteQueuePriorities >= 2);
7121 ret = ret && (vpCheckFlags(s->properties.limits.framebufferColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)));
7122 ret = ret && (vpCheckFlags(s->properties.limits.framebufferDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)));
7123 ret = ret && (vpCheckFlags(s->properties.limits.framebufferNoAttachmentsSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)));
7124 ret = ret && (vpCheckFlags(s->properties.limits.framebufferStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)));
7125 ret = ret && (s->properties.limits.maxBoundDescriptorSets >= 4);
7126 ret = ret && (s->properties.limits.maxColorAttachments >= 4);
7127 ret = ret && (s->properties.limits.maxComputeSharedMemorySize >= 16384);
7128 ret = ret && (s->properties.limits.maxComputeWorkGroupCount[0] >= 65535);
7129 ret = ret && (s->properties.limits.maxComputeWorkGroupCount[1] >= 65535);
7130 ret = ret && (s->properties.limits.maxComputeWorkGroupCount[2] >= 65535);
7131 ret = ret && (s->properties.limits.maxComputeWorkGroupInvocations >= 128);
7132 ret = ret && (s->properties.limits.maxComputeWorkGroupSize[0] >= 128);
7133 ret = ret && (s->properties.limits.maxComputeWorkGroupSize[1] >= 128);
7134 ret = ret && (s->properties.limits.maxComputeWorkGroupSize[2] >= 64);
7135 ret = ret && (s->properties.limits.maxDescriptorSetInputAttachments >= 4);
7136 ret = ret && (s->properties.limits.maxDescriptorSetSampledImages >= 48);
7137 ret = ret && (s->properties.limits.maxDescriptorSetSamplers >= 48);
7138 ret = ret && (s->properties.limits.maxDescriptorSetStorageBuffers >= 24);
7139 ret = ret && (s->properties.limits.maxDescriptorSetStorageBuffersDynamic >= 4);
7140 ret = ret && (s->properties.limits.maxDescriptorSetStorageImages >= 12);
7141 ret = ret && (s->properties.limits.maxDescriptorSetUniformBuffers >= 36);
7142 ret = ret && (s->properties.limits.maxDescriptorSetUniformBuffersDynamic >= 8);
7143 ret = ret && (s->properties.limits.maxDrawIndexedIndexValue >= 4294967295);
7144 ret = ret && (s->properties.limits.maxDrawIndirectCount >= 1);
7145 ret = ret && (s->properties.limits.maxFragmentCombinedOutputResources >= 8);
7146 ret = ret && (s->properties.limits.maxFragmentInputComponents >= 64);
7147 ret = ret && (s->properties.limits.maxFragmentOutputAttachments >= 4);
7148 ret = ret && (s->properties.limits.maxFramebufferHeight >= 4096);
7149 ret = ret && (s->properties.limits.maxFramebufferLayers >= 256);
7150 ret = ret && (s->properties.limits.maxFramebufferWidth >= 4096);
7151 ret = ret && (s->properties.limits.maxImageArrayLayers >= 256);
7152 ret = ret && (s->properties.limits.maxImageDimension1D >= 4096);
7153 ret = ret && (s->properties.limits.maxImageDimension2D >= 4096);
7154 ret = ret && (s->properties.limits.maxImageDimension3D >= 512);
7155 ret = ret && (s->properties.limits.maxImageDimensionCube >= 4096);
7156 ret = ret && (s->properties.limits.maxInterpolationOffset >= 0.4375);
7157 ret = ret && (s->properties.limits.maxMemoryAllocationCount >= 4096);
7158 ret = ret && (s->properties.limits.maxPerStageDescriptorInputAttachments >= 4);
7159 ret = ret && (s->properties.limits.maxPerStageDescriptorSampledImages >= 16);
7160 ret = ret && (s->properties.limits.maxPerStageDescriptorSamplers >= 16);
7161 ret = ret && (s->properties.limits.maxPerStageDescriptorStorageBuffers >= 4);
7162 ret = ret && (s->properties.limits.maxPerStageDescriptorStorageImages >= 4);
7163 ret = ret && (s->properties.limits.maxPerStageDescriptorUniformBuffers >= 12);
7164 ret = ret && (s->properties.limits.maxPerStageResources >= 44);
7165 ret = ret && (s->properties.limits.maxPushConstantsSize >= 128);
7166 ret = ret && (s->properties.limits.maxSampleMaskWords >= 1);
7167 ret = ret && (s->properties.limits.maxSamplerAllocationCount >= 4000);
7168 ret = ret && (s->properties.limits.maxSamplerAnisotropy >= 1.0);
7169 ret = ret && (s->properties.limits.maxSamplerLodBias >= 2.0);
7170 ret = ret && (s->properties.limits.maxStorageBufferRange >= 134217728);
7171 ret = ret && (s->properties.limits.maxTexelBufferElements >= 65536);
7172 ret = ret && (s->properties.limits.maxTexelOffset >= 7);
7173 ret = ret && (s->properties.limits.maxUniformBufferRange >= 16384);
7174 ret = ret && (s->properties.limits.maxVertexInputAttributeOffset >= 2047);
7175 ret = ret && (s->properties.limits.maxVertexInputAttributes >= 16);
7176 ret = ret && (s->properties.limits.maxVertexInputBindingStride >= 2048);
7177 ret = ret && (s->properties.limits.maxVertexInputBindings >= 16);
7178 ret = ret && (s->properties.limits.maxVertexOutputComponents >= 64);
7179 ret = ret && (s->properties.limits.maxViewportDimensions[0] >= 4096);
7180 ret = ret && (s->properties.limits.maxViewportDimensions[1] >= 4096);
7181 ret = ret && (s->properties.limits.maxViewports >= 1);
7182 ret = ret && (s->properties.limits.minInterpolationOffset <= -0.5);
7183 ret = ret && (s->properties.limits.minMemoryMapAlignment <= 4096);
7184 ret = ret && ((s->properties.limits.minMemoryMapAlignment & (s->properties.limits.minMemoryMapAlignment - 1)) == 0);
7185 ret = ret && (s->properties.limits.minStorageBufferOffsetAlignment <= 256);
7186 ret = ret && ((s->properties.limits.minStorageBufferOffsetAlignment & (s->properties.limits.minStorageBufferOffsetAlignment - 1)) == 0);
7187 ret = ret && (s->properties.limits.minTexelBufferOffsetAlignment <= 256);
7188 ret = ret && ((s->properties.limits.minTexelBufferOffsetAlignment & (s->properties.limits.minTexelBufferOffsetAlignment - 1)) == 0);
7189 ret = ret && (s->properties.limits.minTexelOffset <= -8);
7190 ret = ret && (s->properties.limits.minUniformBufferOffsetAlignment <= 256);
7191 ret = ret && ((s->properties.limits.minUniformBufferOffsetAlignment & (s->properties.limits.minUniformBufferOffsetAlignment - 1)) == 0);
7192 ret = ret && (s->properties.limits.mipmapPrecisionBits >= 4);
7193 ret = ret && (s->properties.limits.pointSizeGranularity <= 1);
7194 ret = ret && (isMultiple(1, s->properties.limits.pointSizeGranularity));
7195 ret = ret && (s->properties.limits.pointSizeRange[0] <= 1.0);
7196 ret = ret && (s->properties.limits.pointSizeRange[1] >= 511);
7197 ret = ret && (vpCheckFlags(s->properties.limits.sampledImageColorSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)));
7198 ret = ret && (vpCheckFlags(s->properties.limits.sampledImageDepthSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)));
7199 ret = ret && (vpCheckFlags(s->properties.limits.sampledImageIntegerSampleCounts, (VK_SAMPLE_COUNT_1_BIT)));
7200 ret = ret && (vpCheckFlags(s->properties.limits.sampledImageStencilSampleCounts, (VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT)));
7201 ret = ret && (s->properties.limits.standardSampleLocations == VK_TRUE);
7202 ret = ret && (vpCheckFlags(s->properties.limits.storageImageSampleCounts, (VK_SAMPLE_COUNT_1_BIT)));
7203 ret = ret && (s->properties.limits.subPixelInterpolationOffsetBits >= 4);
7204 ret = ret && (s->properties.limits.subPixelPrecisionBits >= 4);
7205 ret = ret && (s->properties.limits.subTexelPrecisionBits >= 4);
7206 ret = ret && (s->properties.limits.viewportBoundsRange[0] <= -8192);
7207 ret = ret && (s->properties.limits.viewportBoundsRange[1] >= 8191);
7208 } break;
7209 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: {
7210 VkPhysicalDeviceMultiviewProperties* s = static_cast<VkPhysicalDeviceMultiviewProperties*>(static_cast<void*>(p));
7211 ret = ret && (s->maxMultiviewInstanceIndex >= 134217727);
7212 ret = ret && (s->maxMultiviewViewCount >= 6);
7213 } break;
7214 default: break;
7215 }
7216 return ret;
7217 }
7218 };
7219
7220 static const VpFormatDesc formatDesc[] = {
7221 {
7222 VK_FORMAT_A1R5G5B5_UNORM_PACK16,
__anon3431b7521d502() 7223 [](VkBaseOutStructure* p) { (void)p;
7224 switch (p->sType) {
7225 case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: {
7226 VkFormatProperties2KHR* s = static_cast<VkFormatProperties2KHR*>(static_cast<void*>(p));
7227 s->formatProperties.linearTilingFeatures |= (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
7228 s->formatProperties.optimalTilingFeatures |= (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT);
7229 } break;
7230 default: break;
7231 }
7232 },
__anon3431b7521d602() 7233