1 // Copyright 2019 The SwiftShader Authors. All Rights Reserved.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 #include "VkFormat.hpp"
16
17 #include "System/Debug.hpp"
18 #include "System/Math.hpp"
19
20 namespace vk {
21
isUnsignedNormalized() const22 bool Format::isUnsignedNormalized() const
23 {
24 switch(format)
25 {
26 case VK_FORMAT_R4G4_UNORM_PACK8:
27 case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
28 case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
29 case VK_FORMAT_A4R4G4B4_UNORM_PACK16:
30 case VK_FORMAT_A4B4G4R4_UNORM_PACK16:
31 case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
32 case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
33 case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
34 case VK_FORMAT_R5G6B5_UNORM_PACK16:
35 case VK_FORMAT_B5G6R5_UNORM_PACK16:
36 case VK_FORMAT_R8_UNORM:
37 case VK_FORMAT_R8G8_UNORM:
38 case VK_FORMAT_R8G8B8A8_UNORM:
39 case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
40 case VK_FORMAT_B8G8R8A8_UNORM:
41 case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
42 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
43 case VK_FORMAT_R16_UNORM:
44 case VK_FORMAT_R16G16_UNORM:
45 case VK_FORMAT_R16G16B16_UNORM:
46 case VK_FORMAT_R16G16B16A16_UNORM:
47 case VK_FORMAT_D16_UNORM:
48 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
49 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
50 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
51 return true;
52 default:
53 // sRGB encoded formats are also unsigned normalized.
54 // Note that floating-pont formats have no need for nonlinear encoding,
55 // and the sRGB transfer function is only defined for [0.0, 1.0].
56 return isSRGBformat();
57 }
58 }
59
isSignedNormalized() const60 bool Format::isSignedNormalized() const
61 {
62 switch(format)
63 {
64 case VK_FORMAT_R8_SNORM:
65 case VK_FORMAT_R8G8_SNORM:
66 case VK_FORMAT_R8G8B8A8_SNORM:
67 case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
68 case VK_FORMAT_B8G8R8A8_SNORM:
69 case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
70 case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
71 case VK_FORMAT_R16_SNORM:
72 case VK_FORMAT_R16G16_SNORM:
73 case VK_FORMAT_R16G16B16_SNORM:
74 case VK_FORMAT_R16G16B16A16_SNORM:
75 return true;
76 default:
77 return false;
78 }
79 }
80
isSignedUnnormalizedInteger() const81 bool Format::isSignedUnnormalizedInteger() const
82 {
83 switch(format)
84 {
85 case VK_FORMAT_R8_SINT:
86 case VK_FORMAT_R8G8_SINT:
87 case VK_FORMAT_R8G8B8A8_SINT:
88 case VK_FORMAT_B8G8R8A8_SINT:
89 case VK_FORMAT_A8B8G8R8_SINT_PACK32:
90 case VK_FORMAT_A2R10G10B10_SINT_PACK32:
91 case VK_FORMAT_A2B10G10R10_SINT_PACK32:
92 case VK_FORMAT_R16_SINT:
93 case VK_FORMAT_R16G16_SINT:
94 case VK_FORMAT_R16G16B16_SINT:
95 case VK_FORMAT_R16G16B16A16_SINT:
96 case VK_FORMAT_R32_SINT:
97 case VK_FORMAT_R32G32_SINT:
98 case VK_FORMAT_R32G32B32_SINT:
99 case VK_FORMAT_R32G32B32A32_SINT:
100 case VK_FORMAT_R64_SINT:
101 case VK_FORMAT_R64G64_SINT:
102 case VK_FORMAT_R64G64B64_SINT:
103 case VK_FORMAT_R64G64B64A64_SINT:
104 return true;
105 default:
106 return false;
107 }
108 }
109
isUnsignedUnnormalizedInteger() const110 bool Format::isUnsignedUnnormalizedInteger() const
111 {
112 switch(format)
113 {
114 case VK_FORMAT_R8_UINT:
115 case VK_FORMAT_R8G8_UINT:
116 case VK_FORMAT_R8G8B8A8_UINT:
117 case VK_FORMAT_B8G8R8A8_UINT:
118 case VK_FORMAT_A8B8G8R8_UINT_PACK32:
119 case VK_FORMAT_A2R10G10B10_UINT_PACK32:
120 case VK_FORMAT_A2B10G10R10_UINT_PACK32:
121 case VK_FORMAT_R16_UINT:
122 case VK_FORMAT_R16G16_UINT:
123 case VK_FORMAT_R16G16B16_UINT:
124 case VK_FORMAT_R16G16B16A16_UINT:
125 case VK_FORMAT_R32_UINT:
126 case VK_FORMAT_R32G32_UINT:
127 case VK_FORMAT_R32G32B32_UINT:
128 case VK_FORMAT_R32G32B32A32_UINT:
129 case VK_FORMAT_R64_UINT:
130 case VK_FORMAT_R64G64_UINT:
131 case VK_FORMAT_R64G64B64_UINT:
132 case VK_FORMAT_R64G64B64A64_UINT:
133 case VK_FORMAT_S8_UINT:
134 return true;
135 default:
136 return false;
137 }
138 }
139
isUnnormalizedInteger() const140 bool Format::isUnnormalizedInteger() const
141 {
142 return isSignedUnnormalizedInteger() || isUnsignedUnnormalizedInteger();
143 }
144
getAspects() const145 VkImageAspectFlags Format::getAspects() const
146 {
147 // TODO: probably just flatten this out to a full format list, and alter
148 // isDepth / isStencil etc to check for their aspect
149
150 VkImageAspectFlags aspects = 0;
151 if(isDepth()) aspects |= VK_IMAGE_ASPECT_DEPTH_BIT;
152 if(isStencil()) aspects |= VK_IMAGE_ASPECT_STENCIL_BIT;
153
154 // YCbCr formats
155 switch(format)
156 {
157 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
158 aspects = VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT | VK_IMAGE_ASPECT_PLANE_2_BIT;
159 break;
160 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
161 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
162 aspects = VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT;
163 break;
164 default:
165 ASSERT(!isYcbcrFormat());
166 break;
167 }
168
169 // Anything else is "color".
170 if(!aspects) aspects |= VK_IMAGE_ASPECT_COLOR_BIT;
171 return aspects;
172 }
173
getAspectFormat(VkImageAspectFlags aspect) const174 Format Format::getAspectFormat(VkImageAspectFlags aspect) const
175 {
176 switch(aspect)
177 {
178 case VK_IMAGE_ASPECT_COLOR_BIT:
179 case(VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT):
180 case(VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT):
181 case(VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT | VK_IMAGE_ASPECT_PLANE_2_BIT):
182 return format;
183
184 case VK_IMAGE_ASPECT_DEPTH_BIT:
185 switch(format)
186 {
187 case VK_FORMAT_D16_UNORM:
188 case VK_FORMAT_D16_UNORM_S8_UINT:
189 return VK_FORMAT_D16_UNORM;
190 case VK_FORMAT_D24_UNORM_S8_UINT:
191 return VK_FORMAT_X8_D24_UNORM_PACK32;
192 case VK_FORMAT_D32_SFLOAT:
193 case VK_FORMAT_D32_SFLOAT_S8_UINT:
194 return VK_FORMAT_D32_SFLOAT;
195 default:
196 UNSUPPORTED("format %d", int(format));
197 break;
198 }
199 break;
200
201 case VK_IMAGE_ASPECT_STENCIL_BIT:
202 switch(format)
203 {
204 case VK_FORMAT_S8_UINT:
205 case VK_FORMAT_D16_UNORM_S8_UINT:
206 case VK_FORMAT_D24_UNORM_S8_UINT:
207 case VK_FORMAT_D32_SFLOAT_S8_UINT:
208 return VK_FORMAT_S8_UINT;
209 default:
210 UNSUPPORTED("format %d", int(format));
211 break;
212 }
213 break;
214
215 // YCbCr formats
216 // Vulkan 1.1 section 32.1.1. Compatible formats of planes of multi-planar formats
217 case VK_IMAGE_ASPECT_PLANE_0_BIT:
218 switch(format)
219 {
220 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
221 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
222 return VK_FORMAT_R8_UNORM;
223 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
224 return VK_FORMAT_R10X6_UNORM_PACK16;
225 // 8-bit compatibility class
226 // Compatible format for VK_FORMAT_R8_UNORM
227 case VK_FORMAT_R8_UNORM:
228 case VK_FORMAT_R8_UINT:
229 case VK_FORMAT_R8_SINT:
230 // 16-bit compatibility class
231 // Compatible formats with VK_FORMAT_R8G8_UNORM, VK_FORMAT_R10X6_UNORM_PACK16, VK_FORMAT_R12X4_UNORM_PACK16 and VK_FORMAT_R16_UNORM
232 case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
233 case VK_FORMAT_R8G8_UNORM:
234 case VK_FORMAT_R8G8_UINT:
235 case VK_FORMAT_R16_UNORM:
236 case VK_FORMAT_R16_UINT:
237 case VK_FORMAT_R16_SINT:
238 return format;
239 default:
240 UNSUPPORTED("format %d", int(format));
241 break;
242 }
243 break;
244
245 case VK_IMAGE_ASPECT_PLANE_1_BIT:
246 switch(format)
247 {
248 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
249 return VK_FORMAT_R8_UNORM;
250 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
251 return VK_FORMAT_R8G8_UNORM;
252 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
253 return VK_FORMAT_R10X6G10X6_UNORM_2PACK16;
254 // 8-bit compatibility class
255 // Compatible format for VK_FORMAT_R8_UNORM
256 case VK_FORMAT_R8_UNORM:
257 case VK_FORMAT_R8_UINT:
258 case VK_FORMAT_R8_SINT:
259 // 16-bit compatibility class
260 // Compatible formats with VK_FORMAT_R8G8_UNORM, VK_FORMAT_R10X6_UNORM_PACK16, VK_FORMAT_R12X4_UNORM_PACK16 and VK_FORMAT_R16_UNORM
261 case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
262 case VK_FORMAT_R8G8_UNORM:
263 case VK_FORMAT_R8G8_UINT:
264 case VK_FORMAT_R8G8_SINT:
265 case VK_FORMAT_R16_UNORM:
266 case VK_FORMAT_R16_UINT:
267 case VK_FORMAT_R16_SINT:
268 // 32-bit compatibility class
269 // Compatible formats for VK_FORMAT_R10X6G10X6_UNORM_2PACK16, VK_FORMAT_R12X4G12X4_UNORM_2PACK16 and VK_FORMAT_R16G16_UNORM
270 case VK_FORMAT_R8G8B8A8_UNORM:
271 case VK_FORMAT_R8G8B8A8_UINT:
272 case VK_FORMAT_R16G16_UNORM:
273 case VK_FORMAT_R32_UINT:
274 return format;
275 default:
276 UNSUPPORTED("format %d", int(format));
277 break;
278 }
279 break;
280
281 case VK_IMAGE_ASPECT_PLANE_2_BIT:
282 switch(format)
283 {
284 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
285 return VK_FORMAT_R8_UNORM;
286 // 8-bit compatibility class
287 // Compatible format for VK_FORMAT_R8_UNORM
288 case VK_FORMAT_R8_UNORM:
289 case VK_FORMAT_R8_UINT:
290 case VK_FORMAT_R8_SINT:
291 return format;
292 default:
293 UNSUPPORTED("format %d", int(format));
294 break;
295 }
296 break;
297
298 default:
299 UNSUPPORTED("aspect %x", int(aspect));
300 break;
301 }
302
303 return format;
304 }
305
getClearFormat() const306 VkFormat Format::getClearFormat() const
307 {
308 // Set the proper format for the clear value, as described here:
309 // https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#clears-values
310 if(isSignedUnnormalizedInteger())
311 {
312 return VK_FORMAT_R32G32B32A32_SINT;
313 }
314 else if(isUnsignedUnnormalizedInteger())
315 {
316 return VK_FORMAT_R32G32B32A32_UINT;
317 }
318
319 return VK_FORMAT_R32G32B32A32_SFLOAT;
320 }
321
isStencil() const322 bool Format::isStencil() const
323 {
324 switch(format)
325 {
326 case VK_FORMAT_D16_UNORM_S8_UINT:
327 case VK_FORMAT_D24_UNORM_S8_UINT:
328 case VK_FORMAT_S8_UINT:
329 case VK_FORMAT_D32_SFLOAT_S8_UINT:
330 return true;
331 case VK_FORMAT_D16_UNORM:
332 case VK_FORMAT_X8_D24_UNORM_PACK32:
333 case VK_FORMAT_D32_SFLOAT:
334 default:
335 return false;
336 }
337 }
338
isDepth() const339 bool Format::isDepth() const
340 {
341 switch(format)
342 {
343 case VK_FORMAT_D16_UNORM:
344 case VK_FORMAT_D16_UNORM_S8_UINT:
345 case VK_FORMAT_X8_D24_UNORM_PACK32:
346 case VK_FORMAT_D24_UNORM_S8_UINT:
347 case VK_FORMAT_D32_SFLOAT:
348 case VK_FORMAT_D32_SFLOAT_S8_UINT:
349 return true;
350 case VK_FORMAT_S8_UINT:
351 default:
352 return false;
353 }
354 }
355
isSRGBformat() const356 bool Format::isSRGBformat() const
357 {
358 switch(format)
359 {
360 case VK_FORMAT_R8_SRGB:
361 case VK_FORMAT_R8G8_SRGB:
362 case VK_FORMAT_R8G8B8A8_SRGB:
363 case VK_FORMAT_B8G8R8A8_SRGB:
364 case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
365 case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
366 case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
367 case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
368 case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
369 case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
370 case VK_FORMAT_BC2_SRGB_BLOCK:
371 case VK_FORMAT_BC3_SRGB_BLOCK:
372 case VK_FORMAT_ASTC_4x4_SRGB_BLOCK:
373 case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
374 case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
375 case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
376 case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
377 case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
378 case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
379 case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
380 case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
381 case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
382 case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
383 case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
384 case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
385 case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
386 return true;
387 default:
388 return false;
389 }
390 }
391
isFloatFormat() const392 bool Format::isFloatFormat() const
393 {
394 switch(format)
395 {
396 case VK_FORMAT_R4G4_UNORM_PACK8:
397 case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
398 case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
399 case VK_FORMAT_A4R4G4B4_UNORM_PACK16:
400 case VK_FORMAT_A4B4G4R4_UNORM_PACK16:
401 case VK_FORMAT_R5G6B5_UNORM_PACK16:
402 case VK_FORMAT_B5G6R5_UNORM_PACK16:
403 case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
404 case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
405 case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
406 case VK_FORMAT_R8_UNORM:
407 case VK_FORMAT_R8_SNORM:
408 case VK_FORMAT_R8_USCALED:
409 case VK_FORMAT_R8_SSCALED:
410 case VK_FORMAT_R8_UINT:
411 case VK_FORMAT_R8_SINT:
412 case VK_FORMAT_R8_SRGB:
413 case VK_FORMAT_R8G8_UNORM:
414 case VK_FORMAT_R8G8_SNORM:
415 case VK_FORMAT_R8G8_USCALED:
416 case VK_FORMAT_R8G8_SSCALED:
417 case VK_FORMAT_R8G8_UINT:
418 case VK_FORMAT_R8G8_SINT:
419 case VK_FORMAT_R8G8_SRGB:
420 case VK_FORMAT_R8G8B8A8_UNORM:
421 case VK_FORMAT_R8G8B8A8_SNORM:
422 case VK_FORMAT_R8G8B8A8_USCALED:
423 case VK_FORMAT_R8G8B8A8_SSCALED:
424 case VK_FORMAT_R8G8B8A8_UINT:
425 case VK_FORMAT_R8G8B8A8_SINT:
426 case VK_FORMAT_R8G8B8A8_SRGB:
427 case VK_FORMAT_B8G8R8A8_UNORM:
428 case VK_FORMAT_B8G8R8A8_SNORM:
429 case VK_FORMAT_B8G8R8A8_USCALED:
430 case VK_FORMAT_B8G8R8A8_SSCALED:
431 case VK_FORMAT_B8G8R8A8_UINT:
432 case VK_FORMAT_B8G8R8A8_SINT:
433 case VK_FORMAT_B8G8R8A8_SRGB:
434 case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
435 case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
436 case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
437 case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
438 case VK_FORMAT_A8B8G8R8_UINT_PACK32:
439 case VK_FORMAT_A8B8G8R8_SINT_PACK32:
440 case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
441 case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
442 case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
443 case VK_FORMAT_A2R10G10B10_USCALED_PACK32:
444 case VK_FORMAT_A2R10G10B10_SSCALED_PACK32:
445 case VK_FORMAT_A2R10G10B10_UINT_PACK32:
446 case VK_FORMAT_A2R10G10B10_SINT_PACK32:
447 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
448 case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
449 case VK_FORMAT_A2B10G10R10_USCALED_PACK32:
450 case VK_FORMAT_A2B10G10R10_SSCALED_PACK32:
451 case VK_FORMAT_A2B10G10R10_UINT_PACK32:
452 case VK_FORMAT_A2B10G10R10_SINT_PACK32:
453 case VK_FORMAT_R16_UNORM:
454 case VK_FORMAT_R16_SNORM:
455 case VK_FORMAT_R16_USCALED:
456 case VK_FORMAT_R16_SSCALED:
457 case VK_FORMAT_R16_UINT:
458 case VK_FORMAT_R16_SINT:
459 case VK_FORMAT_R16G16_UNORM:
460 case VK_FORMAT_R16G16_SNORM:
461 case VK_FORMAT_R16G16_USCALED:
462 case VK_FORMAT_R16G16_SSCALED:
463 case VK_FORMAT_R16G16_UINT:
464 case VK_FORMAT_R16G16_SINT:
465 case VK_FORMAT_R16G16B16_UNORM:
466 case VK_FORMAT_R16G16B16_SNORM:
467 case VK_FORMAT_R16G16B16_USCALED:
468 case VK_FORMAT_R16G16B16_SSCALED:
469 case VK_FORMAT_R16G16B16_UINT:
470 case VK_FORMAT_R16G16B16_SINT:
471 case VK_FORMAT_R16G16B16A16_UNORM:
472 case VK_FORMAT_R16G16B16A16_SNORM:
473 case VK_FORMAT_R16G16B16A16_USCALED:
474 case VK_FORMAT_R16G16B16A16_SSCALED:
475 case VK_FORMAT_R16G16B16A16_UINT:
476 case VK_FORMAT_R16G16B16A16_SINT:
477 case VK_FORMAT_R32_UINT:
478 case VK_FORMAT_R32_SINT:
479 case VK_FORMAT_R32G32_UINT:
480 case VK_FORMAT_R32G32_SINT:
481 case VK_FORMAT_R32G32B32_UINT:
482 case VK_FORMAT_R32G32B32_SINT:
483 case VK_FORMAT_R32G32B32A32_UINT:
484 case VK_FORMAT_R32G32B32A32_SINT:
485 case VK_FORMAT_R64_UINT:
486 case VK_FORMAT_R64_SINT:
487 case VK_FORMAT_R64G64_UINT:
488 case VK_FORMAT_R64G64_SINT:
489 case VK_FORMAT_R64G64B64_UINT:
490 case VK_FORMAT_R64G64B64_SINT:
491 case VK_FORMAT_R64G64B64A64_UINT:
492 case VK_FORMAT_R64G64B64A64_SINT:
493 case VK_FORMAT_D16_UNORM:
494 case VK_FORMAT_X8_D24_UNORM_PACK32:
495 case VK_FORMAT_S8_UINT:
496 case VK_FORMAT_D16_UNORM_S8_UINT:
497 case VK_FORMAT_D24_UNORM_S8_UINT:
498 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
499 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
500 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
501 return false;
502 case VK_FORMAT_R16_SFLOAT:
503 case VK_FORMAT_R16G16_SFLOAT:
504 case VK_FORMAT_R16G16B16_SFLOAT:
505 case VK_FORMAT_R16G16B16A16_SFLOAT:
506 case VK_FORMAT_R32_SFLOAT:
507 case VK_FORMAT_R32G32_SFLOAT:
508 case VK_FORMAT_R32G32B32_SFLOAT:
509 case VK_FORMAT_R32G32B32A32_SFLOAT:
510 case VK_FORMAT_R64_SFLOAT:
511 case VK_FORMAT_R64G64_SFLOAT:
512 case VK_FORMAT_R64G64B64_SFLOAT:
513 case VK_FORMAT_R64G64B64A64_SFLOAT:
514 case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
515 case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
516 case VK_FORMAT_D32_SFLOAT:
517 case VK_FORMAT_D32_SFLOAT_S8_UINT:
518 return true;
519 default:
520 UNSUPPORTED("Format: %d", int(format));
521 }
522
523 return false;
524 }
525
isYcbcrFormat() const526 bool Format::isYcbcrFormat() const
527 {
528 switch(format)
529 {
530 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
531 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
532 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
533 return true;
534 default:
535 return false;
536 }
537 }
538
isCompressed() const539 bool Format::isCompressed() const
540 {
541 switch(format)
542 {
543 case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
544 case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
545 case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
546 case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
547 case VK_FORMAT_BC2_UNORM_BLOCK:
548 case VK_FORMAT_BC2_SRGB_BLOCK:
549 case VK_FORMAT_BC3_UNORM_BLOCK:
550 case VK_FORMAT_BC3_SRGB_BLOCK:
551 case VK_FORMAT_BC4_UNORM_BLOCK:
552 case VK_FORMAT_BC4_SNORM_BLOCK:
553 case VK_FORMAT_BC5_UNORM_BLOCK:
554 case VK_FORMAT_BC5_SNORM_BLOCK:
555 case VK_FORMAT_BC6H_UFLOAT_BLOCK:
556 case VK_FORMAT_BC6H_SFLOAT_BLOCK:
557 case VK_FORMAT_BC7_UNORM_BLOCK:
558 case VK_FORMAT_BC7_SRGB_BLOCK:
559 case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
560 case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
561 case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
562 case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
563 case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
564 case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
565 case VK_FORMAT_EAC_R11_UNORM_BLOCK:
566 case VK_FORMAT_EAC_R11_SNORM_BLOCK:
567 case VK_FORMAT_EAC_R11G11_UNORM_BLOCK:
568 case VK_FORMAT_EAC_R11G11_SNORM_BLOCK:
569 case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
570 case VK_FORMAT_ASTC_4x4_SRGB_BLOCK:
571 case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
572 case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
573 case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
574 case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
575 case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
576 case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
577 case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
578 case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
579 case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
580 case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
581 case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
582 case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
583 case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
584 case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
585 case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
586 case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
587 case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
588 case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
589 case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
590 case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
591 case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
592 case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
593 case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
594 case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
595 case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
596 case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
597 return true;
598 default:
599 return false;
600 }
601 }
602
getDecompressedFormat() const603 VkFormat Format::getDecompressedFormat() const
604 {
605 // Note: our ETC2 decoder decompresses the 64 bit RGB compressed texel data to B8G8R8
606 switch(format)
607 {
608 case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
609 return VK_FORMAT_B8G8R8A8_UNORM;
610 case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
611 return VK_FORMAT_B8G8R8A8_SRGB;
612 case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
613 case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
614 return VK_FORMAT_B8G8R8A8_UNORM;
615 case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
616 case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
617 return VK_FORMAT_B8G8R8A8_SRGB;
618 case VK_FORMAT_EAC_R11_UNORM_BLOCK:
619 return VK_FORMAT_R16_UNORM;
620 case VK_FORMAT_EAC_R11_SNORM_BLOCK:
621 return VK_FORMAT_R16_SNORM;
622 case VK_FORMAT_EAC_R11G11_UNORM_BLOCK:
623 return VK_FORMAT_R16G16_UNORM;
624 case VK_FORMAT_EAC_R11G11_SNORM_BLOCK:
625 return VK_FORMAT_R16G16_SNORM;
626 case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
627 case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
628 case VK_FORMAT_BC2_UNORM_BLOCK:
629 case VK_FORMAT_BC3_UNORM_BLOCK:
630 case VK_FORMAT_BC7_UNORM_BLOCK:
631 return VK_FORMAT_B8G8R8A8_UNORM;
632 case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
633 case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
634 case VK_FORMAT_BC2_SRGB_BLOCK:
635 case VK_FORMAT_BC3_SRGB_BLOCK:
636 case VK_FORMAT_BC7_SRGB_BLOCK:
637 return VK_FORMAT_B8G8R8A8_SRGB;
638 case VK_FORMAT_BC4_UNORM_BLOCK:
639 return VK_FORMAT_R8_UNORM;
640 case VK_FORMAT_BC4_SNORM_BLOCK:
641 return VK_FORMAT_R8_SNORM;
642 case VK_FORMAT_BC5_UNORM_BLOCK:
643 return VK_FORMAT_R8G8_UNORM;
644 case VK_FORMAT_BC5_SNORM_BLOCK:
645 return VK_FORMAT_R8G8_SNORM;
646 case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
647 case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
648 case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
649 case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
650 case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
651 case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
652 case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
653 case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
654 case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
655 case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
656 case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
657 case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
658 case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
659 case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
660 return VK_FORMAT_R8G8B8A8_UNORM;
661 case VK_FORMAT_ASTC_4x4_SRGB_BLOCK:
662 case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
663 case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
664 case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
665 case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
666 case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
667 case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
668 case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
669 case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
670 case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
671 case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
672 case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
673 case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
674 case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
675 return VK_FORMAT_R8G8B8A8_SRGB;
676 case VK_FORMAT_BC6H_UFLOAT_BLOCK:
677 case VK_FORMAT_BC6H_SFLOAT_BLOCK:
678 return VK_FORMAT_R16G16B16A16_SFLOAT;
679 default:
680 UNSUPPORTED("format: %d", int(format));
681 return VK_FORMAT_UNDEFINED;
682 }
683 }
684
getCompatibleFormats() const685 std::vector<Format> Format::getCompatibleFormats() const
686 {
687 switch(getCompatibilityClassRepresentative())
688 {
689 // 8 - bit, Block size 1 byte, 1 texel / block
690 case VK_FORMAT_R8_UNORM:
691 return {
692 VK_FORMAT_R4G4_UNORM_PACK8,
693 VK_FORMAT_R8_UNORM,
694 VK_FORMAT_R8_SNORM,
695 VK_FORMAT_R8_USCALED,
696 VK_FORMAT_R8_SSCALED,
697 VK_FORMAT_R8_UINT,
698 VK_FORMAT_R8_SINT,
699 VK_FORMAT_R8_SRGB,
700 };
701
702 // 16 - bit, Block size 2 bytes, 1 texel / block
703 case VK_FORMAT_R16_UNORM:
704 return {
705 VK_FORMAT_R4G4B4A4_UNORM_PACK16,
706 VK_FORMAT_B4G4R4A4_UNORM_PACK16,
707 VK_FORMAT_A4R4G4B4_UNORM_PACK16,
708 VK_FORMAT_A4B4G4R4_UNORM_PACK16,
709 VK_FORMAT_R5G6B5_UNORM_PACK16,
710 VK_FORMAT_B5G6R5_UNORM_PACK16,
711 VK_FORMAT_R5G5B5A1_UNORM_PACK16,
712 VK_FORMAT_B5G5R5A1_UNORM_PACK16,
713 VK_FORMAT_A1R5G5B5_UNORM_PACK16,
714 VK_FORMAT_R8G8_UNORM,
715 VK_FORMAT_R8G8_SNORM,
716 VK_FORMAT_R8G8_USCALED,
717 VK_FORMAT_R8G8_SSCALED,
718 VK_FORMAT_R8G8_UINT,
719 VK_FORMAT_R8G8_SINT,
720 VK_FORMAT_R8G8_SRGB,
721 VK_FORMAT_R16_UNORM,
722 VK_FORMAT_R16_SNORM,
723 VK_FORMAT_R16_USCALED,
724 VK_FORMAT_R16_SSCALED,
725 VK_FORMAT_R16_UINT,
726 VK_FORMAT_R16_SINT,
727 VK_FORMAT_R16_SFLOAT,
728 VK_FORMAT_R10X6_UNORM_PACK16,
729 VK_FORMAT_R12X4_UNORM_PACK16,
730 };
731
732 // 32 - bit, Block size 4 bytes, 1 texel / block
733 case VK_FORMAT_R8G8B8A8_UNORM:
734 return {
735 VK_FORMAT_R8G8B8A8_UNORM,
736 VK_FORMAT_R8G8B8A8_SNORM,
737 VK_FORMAT_R8G8B8A8_USCALED,
738 VK_FORMAT_R8G8B8A8_SSCALED,
739 VK_FORMAT_R8G8B8A8_UINT,
740 VK_FORMAT_R8G8B8A8_SINT,
741 VK_FORMAT_R8G8B8A8_SRGB,
742 VK_FORMAT_B8G8R8A8_UNORM,
743 VK_FORMAT_B8G8R8A8_SNORM,
744 VK_FORMAT_B8G8R8A8_USCALED,
745 VK_FORMAT_B8G8R8A8_SSCALED,
746 VK_FORMAT_B8G8R8A8_UINT,
747 VK_FORMAT_B8G8R8A8_SINT,
748 VK_FORMAT_B8G8R8A8_SRGB,
749 VK_FORMAT_A8B8G8R8_UNORM_PACK32,
750 VK_FORMAT_A8B8G8R8_SNORM_PACK32,
751 VK_FORMAT_A8B8G8R8_USCALED_PACK32,
752 VK_FORMAT_A8B8G8R8_SSCALED_PACK32,
753 VK_FORMAT_A8B8G8R8_UINT_PACK32,
754 VK_FORMAT_A8B8G8R8_SINT_PACK32,
755 VK_FORMAT_A8B8G8R8_SRGB_PACK32,
756 VK_FORMAT_A2R10G10B10_UNORM_PACK32,
757 VK_FORMAT_A2R10G10B10_SNORM_PACK32,
758 VK_FORMAT_A2R10G10B10_USCALED_PACK32,
759 VK_FORMAT_A2R10G10B10_SSCALED_PACK32,
760 VK_FORMAT_A2R10G10B10_UINT_PACK32,
761 VK_FORMAT_A2R10G10B10_SINT_PACK32,
762 VK_FORMAT_A2B10G10R10_UNORM_PACK32,
763 VK_FORMAT_A2B10G10R10_SNORM_PACK32,
764 VK_FORMAT_A2B10G10R10_USCALED_PACK32,
765 VK_FORMAT_A2B10G10R10_SSCALED_PACK32,
766 VK_FORMAT_A2B10G10R10_UINT_PACK32,
767 VK_FORMAT_A2B10G10R10_SINT_PACK32,
768 VK_FORMAT_R16G16_UNORM,
769 VK_FORMAT_R16G16_SNORM,
770 VK_FORMAT_R16G16_USCALED,
771 VK_FORMAT_R16G16_SSCALED,
772 VK_FORMAT_R16G16_UINT,
773 VK_FORMAT_R16G16_SINT,
774 VK_FORMAT_R16G16_SFLOAT,
775 VK_FORMAT_R32_UINT,
776 VK_FORMAT_R32_SINT,
777 VK_FORMAT_R32_SFLOAT,
778 VK_FORMAT_B10G11R11_UFLOAT_PACK32,
779 VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
780 VK_FORMAT_R10X6G10X6_UNORM_2PACK16,
781 VK_FORMAT_R12X4G12X4_UNORM_2PACK16,
782 };
783
784 // 48 - bit, Block size 6 bytes, 1 texel / block
785 case VK_FORMAT_R16G16B16_UNORM:
786 return {
787 VK_FORMAT_R16G16B16_UNORM,
788 VK_FORMAT_R16G16B16_SNORM,
789 VK_FORMAT_R16G16B16_USCALED,
790 VK_FORMAT_R16G16B16_SSCALED,
791 VK_FORMAT_R16G16B16_UINT,
792 VK_FORMAT_R16G16B16_SINT,
793 VK_FORMAT_R16G16B16_SFLOAT,
794 };
795
796 // 64 - bit, Block size 8 bytes, 1 texel / block
797 case VK_FORMAT_R16G16B16A16_UNORM:
798 return {
799 VK_FORMAT_R16G16B16A16_UNORM,
800 VK_FORMAT_R16G16B16A16_SNORM,
801 VK_FORMAT_R16G16B16A16_USCALED,
802 VK_FORMAT_R16G16B16A16_SSCALED,
803 VK_FORMAT_R16G16B16A16_UINT,
804 VK_FORMAT_R16G16B16A16_SINT,
805 VK_FORMAT_R16G16B16A16_SFLOAT,
806 VK_FORMAT_R32G32_UINT,
807 VK_FORMAT_R32G32_SINT,
808 VK_FORMAT_R32G32_SFLOAT,
809 VK_FORMAT_R64_UINT,
810 VK_FORMAT_R64_SINT,
811 VK_FORMAT_R64_SFLOAT,
812 };
813
814 // 96 - bit, Block size 12 bytes, 1 texel / block
815 case VK_FORMAT_R32G32B32_UINT:
816 return {
817 VK_FORMAT_R32G32B32_UINT,
818 VK_FORMAT_R32G32B32_SINT,
819 VK_FORMAT_R32G32B32_SFLOAT,
820 };
821
822 // 128 - bit, Block size 16 bytes, 1 texel / block
823 case VK_FORMAT_R32G32B32A32_UINT:
824 return {
825 VK_FORMAT_R32G32B32A32_UINT,
826 VK_FORMAT_R32G32B32A32_SINT,
827 VK_FORMAT_R32G32B32A32_SFLOAT,
828 VK_FORMAT_R64G64_UINT,
829 VK_FORMAT_R64G64_SINT,
830 VK_FORMAT_R64G64_SFLOAT,
831 };
832
833 // 192 - bit, Block size 24 bytes, 1 texel / block
834 case VK_FORMAT_R64G64B64_UINT:
835 return {
836 VK_FORMAT_R64G64B64_UINT,
837 VK_FORMAT_R64G64B64_SINT,
838 VK_FORMAT_R64G64B64_SFLOAT,
839 };
840
841 // 256 - bit, Block size 32 bytes, 1 texel / block
842 case VK_FORMAT_R64G64B64A64_UINT:
843 return {
844 VK_FORMAT_R64G64B64A64_UINT,
845 VK_FORMAT_R64G64B64A64_SINT,
846 VK_FORMAT_R64G64B64A64_SFLOAT,
847 };
848
849 // BC1_RGB(64 bit), Block size 8 bytes, 16 texels / block
850 case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
851 return {
852 VK_FORMAT_BC1_RGB_UNORM_BLOCK,
853 VK_FORMAT_BC1_RGB_SRGB_BLOCK,
854 };
855
856 // BC1_RGBA(64 bit), Block size 8 bytes, 16 texels / block
857 case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
858 return {
859 VK_FORMAT_BC1_RGBA_UNORM_BLOCK,
860 VK_FORMAT_BC1_RGBA_SRGB_BLOCK,
861 };
862
863 // BC2(128 bit), Block size 16 bytes, 16 texels / block
864 case VK_FORMAT_BC2_UNORM_BLOCK:
865 return {
866 VK_FORMAT_BC2_UNORM_BLOCK,
867 VK_FORMAT_BC2_SRGB_BLOCK,
868 };
869
870 // BC3(128 bit), Block size 16 bytes, 16 texels / block
871 case VK_FORMAT_BC3_UNORM_BLOCK:
872 return {
873 VK_FORMAT_BC3_UNORM_BLOCK,
874 VK_FORMAT_BC3_SRGB_BLOCK,
875 };
876
877 // BC4(64 bit), Block size 8 bytes, 16 texels / block
878 case VK_FORMAT_BC4_UNORM_BLOCK:
879 return {
880 VK_FORMAT_BC4_UNORM_BLOCK,
881 VK_FORMAT_BC4_SNORM_BLOCK,
882 };
883
884 // BC5(128 bit), Block size 16 bytes, 16 texels / block
885 case VK_FORMAT_BC5_UNORM_BLOCK:
886 return {
887 VK_FORMAT_BC5_UNORM_BLOCK,
888 VK_FORMAT_BC5_SNORM_BLOCK,
889 };
890
891 // BC6H(128 bit), Block size 16 bytes, 16 texels / block
892 case VK_FORMAT_BC6H_UFLOAT_BLOCK:
893 return {
894 VK_FORMAT_BC6H_UFLOAT_BLOCK,
895 VK_FORMAT_BC6H_SFLOAT_BLOCK,
896 };
897
898 // BC7(128 bit), Block size 16 bytes, 16 texels / block
899 case VK_FORMAT_BC7_UNORM_BLOCK:
900 return {
901 VK_FORMAT_BC7_UNORM_BLOCK,
902 VK_FORMAT_BC7_SRGB_BLOCK,
903 };
904
905 // ETC2_RGB(64 bit), Block size 8 bytes, 16 texels / block
906 case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
907 return {
908 VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
909 VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
910 };
911
912 // ETC2_RGBA(64 bit), Block size 8 bytes, 16 texels / block
913 case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
914 return {
915 VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
916 VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
917 };
918
919 // ETC2_EAC_RGBA(64 bit), Block size 8 bytes, 16 texels / block
920 case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
921 return {
922 VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
923 VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,
924 };
925
926 // EAC_R(64 bit), Block size 8 bytes, 16 texels / block
927 case VK_FORMAT_EAC_R11_UNORM_BLOCK:
928 return {
929 VK_FORMAT_EAC_R11_UNORM_BLOCK,
930 VK_FORMAT_EAC_R11_SNORM_BLOCK,
931 };
932
933 // EAC_RG(128 bit), Block size 16 bytes, 16 texels / block
934 case VK_FORMAT_EAC_R11G11_UNORM_BLOCK:
935 return {
936 VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
937 VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
938 };
939
940 // ASTC_4x4(128 bit), Block size 16 bytes, 16 texels / block
941 case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
942 return {
943 VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
944 VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
945 };
946
947 // ASTC_5x4(128 bit), Block size 16 bytes, 20 texels / block
948 case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
949 return {
950 VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
951 VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
952 };
953
954 // ASTC_5x5(128 bit), Block size 16 bytes, 25 texels / block
955 case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
956 return {
957 VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
958 VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
959 };
960
961 // ASTC_6x5(128 bit), Block size 16 bytes, 30 texels / block
962 case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
963 return {
964 VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
965 VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
966 };
967
968 // ASTC_6x6(128 bit), Block size 16 bytes, 36 texels / block
969 case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
970 return {
971 VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
972 VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
973 };
974
975 // ASTC_8x5(128 bit), Block size 16 bytes, 40 texels / block
976 case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
977 return {
978 VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
979 VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
980 };
981
982 // ASTC_8x6(128 bit), Block size 16 bytes, 48 texels / block
983 case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
984 return {
985 VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
986 VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
987 };
988
989 // ASTC_8x8(128 bit), Block size 16 bytes, 64 texels / block
990 case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
991 return {
992 VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
993 VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
994 };
995
996 // ASTC_10x5(128 bit), Block size 16 bytes, 50 texels / block
997 case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
998 return {
999 VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
1000 VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
1001 };
1002
1003 // ASTC_10x6(128 bit), Block size 16 bytes, 60 texels / block
1004 case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
1005 return {
1006 VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
1007 VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
1008 };
1009
1010 // ASTC_10x8(128 bit), Block size 16 bytes, 80 texels / block
1011 case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
1012 return {
1013 VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
1014 VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
1015 };
1016
1017 // ASTC_10x10(128 bit), Block size 16 bytes, 100 texels / block
1018 case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
1019 return {
1020 VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
1021 VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
1022 };
1023
1024 // ASTC_12x10(128 bit), Block size 16 bytes, 120 texels / block
1025 case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
1026 return {
1027 VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
1028 VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
1029 };
1030
1031 // ASTC_12x12(128 bit), Block size 16 bytes, 144 texels / block
1032 case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
1033 return {
1034 VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
1035 VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
1036 };
1037
1038 // All other formats are only compatible with themselves
1039 default:
1040 ASSERT(getCompatibilityClassRepresentative() == format);
1041 return { format };
1042 }
1043 }
1044
1045 // Returns a single format per class of compatible formats.
getCompatibilityClassRepresentative() const1046 VkFormat Format::getCompatibilityClassRepresentative() const
1047 {
1048 // According to the Vulkan 1.1 Spec, 37.1.6. Format Compatibility Classes:
1049 // "Uncompressed color formats are compatible with each other if they occupy
1050 // the same number of bits per texel block. Compressed color formats are
1051 // compatible with each other if the only difference between them is the
1052 // numerical type of the uncompressed pixels (e.g. signed vs. unsigned, or
1053 // SRGB vs. UNORM encoding). Each depth/stencil format is only compatible
1054 // with itself. In the following table, all the formats in the same row are
1055 // compatible."
1056
1057 switch(format)
1058 {
1059 // 8 - bit, Block size 1 byte, 1 texel / block
1060 case VK_FORMAT_R4G4_UNORM_PACK8:
1061 case VK_FORMAT_R8_UNORM:
1062 case VK_FORMAT_R8_SNORM:
1063 case VK_FORMAT_R8_USCALED:
1064 case VK_FORMAT_R8_SSCALED:
1065 case VK_FORMAT_R8_UINT:
1066 case VK_FORMAT_R8_SINT:
1067 case VK_FORMAT_R8_SRGB:
1068 return VK_FORMAT_R8_UNORM;
1069
1070 // 16 - bit, Block size 2 bytes, 1 texel / block
1071 case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
1072 case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
1073 case VK_FORMAT_A4R4G4B4_UNORM_PACK16:
1074 case VK_FORMAT_A4B4G4R4_UNORM_PACK16:
1075 case VK_FORMAT_R5G6B5_UNORM_PACK16:
1076 case VK_FORMAT_B5G6R5_UNORM_PACK16:
1077 case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
1078 case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
1079 case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
1080 case VK_FORMAT_R8G8_UNORM:
1081 case VK_FORMAT_R8G8_SNORM:
1082 case VK_FORMAT_R8G8_USCALED:
1083 case VK_FORMAT_R8G8_SSCALED:
1084 case VK_FORMAT_R8G8_UINT:
1085 case VK_FORMAT_R8G8_SINT:
1086 case VK_FORMAT_R8G8_SRGB:
1087 case VK_FORMAT_R16_UNORM:
1088 case VK_FORMAT_R16_SNORM:
1089 case VK_FORMAT_R16_USCALED:
1090 case VK_FORMAT_R16_SSCALED:
1091 case VK_FORMAT_R16_UINT:
1092 case VK_FORMAT_R16_SINT:
1093 case VK_FORMAT_R16_SFLOAT:
1094 case VK_FORMAT_R10X6_UNORM_PACK16:
1095 case VK_FORMAT_R12X4_UNORM_PACK16:
1096 return VK_FORMAT_R16_UNORM;
1097
1098 // 32 - bit, Block size 4 bytes, 1 texel / block
1099 case VK_FORMAT_R8G8B8A8_UNORM:
1100 case VK_FORMAT_R8G8B8A8_SNORM:
1101 case VK_FORMAT_R8G8B8A8_USCALED:
1102 case VK_FORMAT_R8G8B8A8_SSCALED:
1103 case VK_FORMAT_R8G8B8A8_UINT:
1104 case VK_FORMAT_R8G8B8A8_SINT:
1105 case VK_FORMAT_R8G8B8A8_SRGB:
1106 case VK_FORMAT_B8G8R8A8_UNORM:
1107 case VK_FORMAT_B8G8R8A8_SNORM:
1108 case VK_FORMAT_B8G8R8A8_USCALED:
1109 case VK_FORMAT_B8G8R8A8_SSCALED:
1110 case VK_FORMAT_B8G8R8A8_UINT:
1111 case VK_FORMAT_B8G8R8A8_SINT:
1112 case VK_FORMAT_B8G8R8A8_SRGB:
1113 case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
1114 case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
1115 case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
1116 case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
1117 case VK_FORMAT_A8B8G8R8_UINT_PACK32:
1118 case VK_FORMAT_A8B8G8R8_SINT_PACK32:
1119 case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
1120 case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
1121 case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
1122 case VK_FORMAT_A2R10G10B10_USCALED_PACK32:
1123 case VK_FORMAT_A2R10G10B10_SSCALED_PACK32:
1124 case VK_FORMAT_A2R10G10B10_UINT_PACK32:
1125 case VK_FORMAT_A2R10G10B10_SINT_PACK32:
1126 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
1127 case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
1128 case VK_FORMAT_A2B10G10R10_USCALED_PACK32:
1129 case VK_FORMAT_A2B10G10R10_SSCALED_PACK32:
1130 case VK_FORMAT_A2B10G10R10_UINT_PACK32:
1131 case VK_FORMAT_A2B10G10R10_SINT_PACK32:
1132 case VK_FORMAT_R16G16_UNORM:
1133 case VK_FORMAT_R16G16_SNORM:
1134 case VK_FORMAT_R16G16_USCALED:
1135 case VK_FORMAT_R16G16_SSCALED:
1136 case VK_FORMAT_R16G16_UINT:
1137 case VK_FORMAT_R16G16_SINT:
1138 case VK_FORMAT_R16G16_SFLOAT:
1139 case VK_FORMAT_R32_UINT:
1140 case VK_FORMAT_R32_SINT:
1141 case VK_FORMAT_R32_SFLOAT:
1142 case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
1143 case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
1144 case VK_FORMAT_R10X6G10X6_UNORM_2PACK16:
1145 case VK_FORMAT_R12X4G12X4_UNORM_2PACK16:
1146 return VK_FORMAT_R8G8B8A8_UNORM;
1147
1148 // 48 - bit, Block size 6 bytes, 1 texel / block
1149 case VK_FORMAT_R16G16B16_UNORM:
1150 case VK_FORMAT_R16G16B16_SNORM:
1151 case VK_FORMAT_R16G16B16_USCALED:
1152 case VK_FORMAT_R16G16B16_SSCALED:
1153 case VK_FORMAT_R16G16B16_UINT:
1154 case VK_FORMAT_R16G16B16_SINT:
1155 case VK_FORMAT_R16G16B16_SFLOAT:
1156 return VK_FORMAT_R16G16B16_UNORM;
1157
1158 // 64 - bit, Block size 8 bytes, 1 texel / block
1159 case VK_FORMAT_R16G16B16A16_UNORM:
1160 case VK_FORMAT_R16G16B16A16_SNORM:
1161 case VK_FORMAT_R16G16B16A16_USCALED:
1162 case VK_FORMAT_R16G16B16A16_SSCALED:
1163 case VK_FORMAT_R16G16B16A16_UINT:
1164 case VK_FORMAT_R16G16B16A16_SINT:
1165 case VK_FORMAT_R16G16B16A16_SFLOAT:
1166 case VK_FORMAT_R32G32_UINT:
1167 case VK_FORMAT_R32G32_SINT:
1168 case VK_FORMAT_R32G32_SFLOAT:
1169 case VK_FORMAT_R64_UINT:
1170 case VK_FORMAT_R64_SINT:
1171 case VK_FORMAT_R64_SFLOAT:
1172 return VK_FORMAT_R16G16B16A16_UNORM;
1173
1174 // 96 - bit, Block size 12 bytes, 1 texel / block
1175 case VK_FORMAT_R32G32B32_UINT:
1176 case VK_FORMAT_R32G32B32_SINT:
1177 case VK_FORMAT_R32G32B32_SFLOAT:
1178 return VK_FORMAT_R32G32B32_UINT;
1179
1180 // 128 - bit, Block size 16 bytes, 1 texel / block
1181 case VK_FORMAT_R32G32B32A32_UINT:
1182 case VK_FORMAT_R32G32B32A32_SINT:
1183 case VK_FORMAT_R32G32B32A32_SFLOAT:
1184 case VK_FORMAT_R64G64_UINT:
1185 case VK_FORMAT_R64G64_SINT:
1186 case VK_FORMAT_R64G64_SFLOAT:
1187 return VK_FORMAT_R32G32B32A32_UINT;
1188
1189 // 192 - bit, Block size 24 bytes, 1 texel / block
1190 case VK_FORMAT_R64G64B64_UINT:
1191 case VK_FORMAT_R64G64B64_SINT:
1192 case VK_FORMAT_R64G64B64_SFLOAT:
1193 return VK_FORMAT_R64G64B64_UINT;
1194
1195 // 256 - bit, Block size 32 bytes, 1 texel / block
1196 case VK_FORMAT_R64G64B64A64_UINT:
1197 case VK_FORMAT_R64G64B64A64_SINT:
1198 case VK_FORMAT_R64G64B64A64_SFLOAT:
1199 return VK_FORMAT_R64G64B64A64_UINT;
1200
1201 // BC1_RGB(64 bit), Block size 8 bytes, 16 texels / block
1202 case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
1203 case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
1204 return VK_FORMAT_BC1_RGB_UNORM_BLOCK;
1205
1206 // BC1_RGBA(64 bit), Block size 8 bytes, 16 texels / block
1207 case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
1208 case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
1209 return VK_FORMAT_BC1_RGBA_UNORM_BLOCK;
1210
1211 // BC2(128 bit), Block size 16 bytes, 16 texels / block
1212 case VK_FORMAT_BC2_UNORM_BLOCK:
1213 case VK_FORMAT_BC2_SRGB_BLOCK:
1214 return VK_FORMAT_BC2_UNORM_BLOCK;
1215
1216 // BC3(128 bit), Block size 16 bytes, 16 texels / block
1217 case VK_FORMAT_BC3_UNORM_BLOCK:
1218 case VK_FORMAT_BC3_SRGB_BLOCK:
1219 return VK_FORMAT_BC3_UNORM_BLOCK;
1220
1221 // BC4(64 bit), Block size 8 bytes, 16 texels / block
1222 case VK_FORMAT_BC4_UNORM_BLOCK:
1223 case VK_FORMAT_BC4_SNORM_BLOCK:
1224 return VK_FORMAT_BC4_UNORM_BLOCK;
1225
1226 // BC5(128 bit), Block size 16 bytes, 16 texels / block
1227 case VK_FORMAT_BC5_UNORM_BLOCK:
1228 case VK_FORMAT_BC5_SNORM_BLOCK:
1229 return VK_FORMAT_BC5_UNORM_BLOCK;
1230
1231 // BC6H(128 bit), Block size 16 bytes, 16 texels / block
1232 case VK_FORMAT_BC6H_UFLOAT_BLOCK:
1233 case VK_FORMAT_BC6H_SFLOAT_BLOCK:
1234 return VK_FORMAT_BC6H_UFLOAT_BLOCK;
1235
1236 // BC7(128 bit), Block size 16 bytes, 16 texels / block
1237 case VK_FORMAT_BC7_UNORM_BLOCK:
1238 case VK_FORMAT_BC7_SRGB_BLOCK:
1239 return VK_FORMAT_BC7_UNORM_BLOCK;
1240
1241 // ETC2_RGB(64 bit), Block size 8 bytes, 16 texels / block
1242 case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
1243 case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
1244 return VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK;
1245
1246 // ETC2_RGBA(64 bit), Block size 8 bytes, 16 texels / block
1247 case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
1248 case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
1249 return VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK;
1250
1251 // ETC2_EAC_RGBA(64 bit), Block size 8 bytes, 16 texels / block
1252 case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
1253 case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
1254 return VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK;
1255
1256 // EAC_R(64 bit), Block size 8 bytes, 16 texels / block
1257 case VK_FORMAT_EAC_R11_UNORM_BLOCK:
1258 case VK_FORMAT_EAC_R11_SNORM_BLOCK:
1259 return VK_FORMAT_EAC_R11_UNORM_BLOCK;
1260
1261 // EAC_RG(128 bit), Block size 16 bytes, 16 texels / block
1262 case VK_FORMAT_EAC_R11G11_UNORM_BLOCK:
1263 case VK_FORMAT_EAC_R11G11_SNORM_BLOCK:
1264 return VK_FORMAT_EAC_R11G11_UNORM_BLOCK;
1265
1266 // ASTC_4x4(128 bit), Block size 16 bytes, 16 texels / block
1267 case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
1268 case VK_FORMAT_ASTC_4x4_SRGB_BLOCK:
1269 return VK_FORMAT_ASTC_4x4_UNORM_BLOCK;
1270
1271 // ASTC_5x4(128 bit), Block size 16 bytes, 20 texels / block
1272 case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
1273 case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
1274 return VK_FORMAT_ASTC_5x4_UNORM_BLOCK;
1275
1276 // ASTC_5x5(128 bit), Block size 16 bytes, 25 texels / block
1277 case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
1278 case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
1279 return VK_FORMAT_ASTC_5x5_UNORM_BLOCK;
1280
1281 // ASTC_6x5(128 bit), Block size 16 bytes, 30 texels / block
1282 case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
1283 case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
1284 return VK_FORMAT_ASTC_6x5_UNORM_BLOCK;
1285
1286 // ASTC_6x6(128 bit), Block size 16 bytes, 36 texels / block
1287 case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
1288 case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
1289 return VK_FORMAT_ASTC_6x6_UNORM_BLOCK;
1290
1291 // ASTC_8x5(128 bit), Block size 16 bytes, 40 texels / block
1292 case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
1293 case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
1294 return VK_FORMAT_ASTC_8x5_UNORM_BLOCK;
1295
1296 // ASTC_8x6(128 bit), Block size 16 bytes, 48 texels / block
1297 case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
1298 case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
1299 return VK_FORMAT_ASTC_8x6_UNORM_BLOCK;
1300
1301 // ASTC_8x8(128 bit), Block size 16 bytes, 64 texels / block
1302 case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
1303 case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
1304 return VK_FORMAT_ASTC_8x8_UNORM_BLOCK;
1305
1306 // ASTC_10x5(128 bit), Block size 16 bytes, 50 texels / block
1307 case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
1308 case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
1309 return VK_FORMAT_ASTC_10x5_UNORM_BLOCK;
1310
1311 // ASTC_10x6(128 bit), Block size 16 bytes, 60 texels / block
1312 case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
1313 case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
1314 return VK_FORMAT_ASTC_10x6_UNORM_BLOCK;
1315
1316 // ASTC_10x8(128 bit), Block size 16 bytes, 80 texels / block
1317 case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
1318 case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
1319 return VK_FORMAT_ASTC_10x8_UNORM_BLOCK;
1320
1321 // ASTC_10x10(128 bit), Block size 16 bytes, 100 texels / block
1322 case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
1323 case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
1324 return VK_FORMAT_ASTC_10x10_UNORM_BLOCK;
1325
1326 // ASTC_12x10(128 bit), Block size 16 bytes, 120 texels / block
1327 case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
1328 case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
1329 return VK_FORMAT_ASTC_12x10_UNORM_BLOCK;
1330
1331 // ASTC_12x12(128 bit), Block size 16 bytes, 144 texels / block
1332 case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
1333 case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
1334 return VK_FORMAT_ASTC_12x12_UNORM_BLOCK;
1335
1336 // All other formats are only compatible with themselves
1337 default:
1338 return format;
1339 }
1340 }
1341
isCompatible(Format other) const1342 bool Format::isCompatible(Format other) const
1343 {
1344 return getCompatibilityClassRepresentative() == other.getCompatibilityClassRepresentative();
1345 }
1346
blockWidth() const1347 int Format::blockWidth() const
1348 {
1349 switch(format)
1350 {
1351 case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
1352 case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
1353 case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
1354 case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
1355 case VK_FORMAT_BC2_UNORM_BLOCK:
1356 case VK_FORMAT_BC2_SRGB_BLOCK:
1357 case VK_FORMAT_BC3_UNORM_BLOCK:
1358 case VK_FORMAT_BC3_SRGB_BLOCK:
1359 case VK_FORMAT_BC4_UNORM_BLOCK:
1360 case VK_FORMAT_BC4_SNORM_BLOCK:
1361 case VK_FORMAT_BC5_UNORM_BLOCK:
1362 case VK_FORMAT_BC5_SNORM_BLOCK:
1363 case VK_FORMAT_BC6H_UFLOAT_BLOCK:
1364 case VK_FORMAT_BC6H_SFLOAT_BLOCK:
1365 case VK_FORMAT_BC7_UNORM_BLOCK:
1366 case VK_FORMAT_BC7_SRGB_BLOCK:
1367 case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
1368 case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
1369 case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
1370 case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
1371 case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
1372 case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
1373 case VK_FORMAT_EAC_R11_UNORM_BLOCK:
1374 case VK_FORMAT_EAC_R11_SNORM_BLOCK:
1375 case VK_FORMAT_EAC_R11G11_UNORM_BLOCK:
1376 case VK_FORMAT_EAC_R11G11_SNORM_BLOCK:
1377 case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
1378 case VK_FORMAT_ASTC_4x4_SRGB_BLOCK:
1379 return 4;
1380 case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
1381 case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
1382 case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
1383 case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
1384 return 5;
1385 case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
1386 case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
1387 case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
1388 case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
1389 return 6;
1390 case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
1391 case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
1392 case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
1393 case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
1394 case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
1395 case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
1396 return 8;
1397 case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
1398 case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
1399 case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
1400 case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
1401 case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
1402 case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
1403 case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
1404 case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
1405 return 10;
1406 case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
1407 case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
1408 case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
1409 case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
1410 return 12;
1411 default:
1412 return 1;
1413 }
1414 }
1415
blockHeight() const1416 int Format::blockHeight() const
1417 {
1418 switch(format)
1419 {
1420 case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
1421 case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
1422 case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
1423 case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
1424 case VK_FORMAT_BC2_UNORM_BLOCK:
1425 case VK_FORMAT_BC2_SRGB_BLOCK:
1426 case VK_FORMAT_BC3_UNORM_BLOCK:
1427 case VK_FORMAT_BC3_SRGB_BLOCK:
1428 case VK_FORMAT_BC4_UNORM_BLOCK:
1429 case VK_FORMAT_BC4_SNORM_BLOCK:
1430 case VK_FORMAT_BC5_UNORM_BLOCK:
1431 case VK_FORMAT_BC5_SNORM_BLOCK:
1432 case VK_FORMAT_BC6H_UFLOAT_BLOCK:
1433 case VK_FORMAT_BC6H_SFLOAT_BLOCK:
1434 case VK_FORMAT_BC7_UNORM_BLOCK:
1435 case VK_FORMAT_BC7_SRGB_BLOCK:
1436 case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
1437 case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
1438 case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
1439 case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
1440 case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
1441 case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
1442 case VK_FORMAT_EAC_R11_UNORM_BLOCK:
1443 case VK_FORMAT_EAC_R11_SNORM_BLOCK:
1444 case VK_FORMAT_EAC_R11G11_UNORM_BLOCK:
1445 case VK_FORMAT_EAC_R11G11_SNORM_BLOCK:
1446 case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
1447 case VK_FORMAT_ASTC_4x4_SRGB_BLOCK:
1448 case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
1449 case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
1450 return 4;
1451 case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
1452 case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
1453 case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
1454 case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
1455 case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
1456 case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
1457 case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
1458 case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
1459 return 5;
1460 case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
1461 case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
1462 case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
1463 case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
1464 case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
1465 case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
1466 return 6;
1467 case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
1468 case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
1469 case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
1470 case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
1471 return 8;
1472 case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
1473 case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
1474 case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
1475 case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
1476 return 10;
1477 case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
1478 case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
1479 return 12;
1480 default:
1481 return 1;
1482 }
1483 }
1484
bytesPerBlock() const1485 int Format::bytesPerBlock() const
1486 {
1487 switch(format)
1488 {
1489 case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
1490 case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
1491 case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
1492 case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
1493 case VK_FORMAT_BC4_UNORM_BLOCK:
1494 case VK_FORMAT_BC4_SNORM_BLOCK:
1495 case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
1496 case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
1497 case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
1498 case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
1499 case VK_FORMAT_EAC_R11_UNORM_BLOCK:
1500 case VK_FORMAT_EAC_R11_SNORM_BLOCK:
1501 return 8;
1502 case VK_FORMAT_BC2_UNORM_BLOCK:
1503 case VK_FORMAT_BC2_SRGB_BLOCK:
1504 case VK_FORMAT_BC3_UNORM_BLOCK:
1505 case VK_FORMAT_BC3_SRGB_BLOCK:
1506 case VK_FORMAT_BC5_UNORM_BLOCK:
1507 case VK_FORMAT_BC5_SNORM_BLOCK:
1508 case VK_FORMAT_BC6H_UFLOAT_BLOCK:
1509 case VK_FORMAT_BC6H_SFLOAT_BLOCK:
1510 case VK_FORMAT_BC7_UNORM_BLOCK:
1511 case VK_FORMAT_BC7_SRGB_BLOCK:
1512 case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
1513 case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
1514 case VK_FORMAT_EAC_R11G11_UNORM_BLOCK:
1515 case VK_FORMAT_EAC_R11G11_SNORM_BLOCK:
1516 case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
1517 case VK_FORMAT_ASTC_4x4_SRGB_BLOCK:
1518 case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
1519 case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
1520 case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
1521 case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
1522 case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
1523 case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
1524 case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
1525 case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
1526 case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
1527 case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
1528 case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
1529 case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
1530 case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
1531 case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
1532 case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
1533 case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
1534 case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
1535 case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
1536 case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
1537 case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
1538 case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
1539 case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
1540 case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
1541 case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
1542 case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
1543 case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
1544 return 16;
1545 default:
1546 return bytes();
1547 }
1548 }
1549
componentCount() const1550 int Format::componentCount() const
1551 {
1552 switch(format)
1553 {
1554 case VK_FORMAT_R8_UNORM:
1555 case VK_FORMAT_R8_SNORM:
1556 case VK_FORMAT_R8_USCALED:
1557 case VK_FORMAT_R8_SSCALED:
1558 case VK_FORMAT_R8_UINT:
1559 case VK_FORMAT_R8_SINT:
1560 case VK_FORMAT_R8_SRGB:
1561 case VK_FORMAT_R16_UNORM:
1562 case VK_FORMAT_R16_SNORM:
1563 case VK_FORMAT_R16_USCALED:
1564 case VK_FORMAT_R16_SSCALED:
1565 case VK_FORMAT_R16_UINT:
1566 case VK_FORMAT_R16_SINT:
1567 case VK_FORMAT_R16_SFLOAT:
1568 case VK_FORMAT_R32_UINT:
1569 case VK_FORMAT_R32_SINT:
1570 case VK_FORMAT_R32_SFLOAT:
1571 case VK_FORMAT_R64_UINT:
1572 case VK_FORMAT_R64_SINT:
1573 case VK_FORMAT_R64_SFLOAT:
1574 case VK_FORMAT_D16_UNORM:
1575 case VK_FORMAT_X8_D24_UNORM_PACK32:
1576 case VK_FORMAT_D32_SFLOAT:
1577 case VK_FORMAT_S8_UINT:
1578 case VK_FORMAT_D16_UNORM_S8_UINT:
1579 case VK_FORMAT_D24_UNORM_S8_UINT:
1580 case VK_FORMAT_D32_SFLOAT_S8_UINT:
1581 case VK_FORMAT_BC4_UNORM_BLOCK:
1582 case VK_FORMAT_BC4_SNORM_BLOCK:
1583 case VK_FORMAT_EAC_R11_UNORM_BLOCK:
1584 case VK_FORMAT_EAC_R11_SNORM_BLOCK:
1585 return 1;
1586 case VK_FORMAT_R4G4_UNORM_PACK8:
1587 case VK_FORMAT_R8G8_UNORM:
1588 case VK_FORMAT_R8G8_SNORM:
1589 case VK_FORMAT_R8G8_USCALED:
1590 case VK_FORMAT_R8G8_SSCALED:
1591 case VK_FORMAT_R8G8_UINT:
1592 case VK_FORMAT_R8G8_SINT:
1593 case VK_FORMAT_R8G8_SRGB:
1594 case VK_FORMAT_R16G16_UNORM:
1595 case VK_FORMAT_R16G16_SNORM:
1596 case VK_FORMAT_R16G16_USCALED:
1597 case VK_FORMAT_R16G16_SSCALED:
1598 case VK_FORMAT_R16G16_UINT:
1599 case VK_FORMAT_R16G16_SINT:
1600 case VK_FORMAT_R16G16_SFLOAT:
1601 case VK_FORMAT_R32G32_UINT:
1602 case VK_FORMAT_R32G32_SINT:
1603 case VK_FORMAT_R32G32_SFLOAT:
1604 case VK_FORMAT_R64G64_UINT:
1605 case VK_FORMAT_R64G64_SINT:
1606 case VK_FORMAT_R64G64_SFLOAT:
1607 case VK_FORMAT_BC5_UNORM_BLOCK:
1608 case VK_FORMAT_BC5_SNORM_BLOCK:
1609 case VK_FORMAT_EAC_R11G11_UNORM_BLOCK:
1610 case VK_FORMAT_EAC_R11G11_SNORM_BLOCK:
1611 return 2;
1612 case VK_FORMAT_R5G6B5_UNORM_PACK16:
1613 case VK_FORMAT_B5G6R5_UNORM_PACK16:
1614 case VK_FORMAT_R16G16B16_UNORM:
1615 case VK_FORMAT_R16G16B16_SNORM:
1616 case VK_FORMAT_R16G16B16_USCALED:
1617 case VK_FORMAT_R16G16B16_SSCALED:
1618 case VK_FORMAT_R16G16B16_UINT:
1619 case VK_FORMAT_R16G16B16_SINT:
1620 case VK_FORMAT_R16G16B16_SFLOAT:
1621 case VK_FORMAT_R32G32B32_UINT:
1622 case VK_FORMAT_R32G32B32_SINT:
1623 case VK_FORMAT_R32G32B32_SFLOAT:
1624 case VK_FORMAT_R64G64B64_UINT:
1625 case VK_FORMAT_R64G64B64_SINT:
1626 case VK_FORMAT_R64G64B64_SFLOAT:
1627 case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
1628 case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
1629 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
1630 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
1631 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
1632 case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
1633 case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
1634 case VK_FORMAT_BC6H_UFLOAT_BLOCK:
1635 case VK_FORMAT_BC6H_SFLOAT_BLOCK:
1636 case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
1637 case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
1638 return 3;
1639 case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
1640 case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
1641 case VK_FORMAT_A4R4G4B4_UNORM_PACK16:
1642 case VK_FORMAT_A4B4G4R4_UNORM_PACK16:
1643 case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
1644 case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
1645 case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
1646 case VK_FORMAT_R8G8B8A8_UNORM:
1647 case VK_FORMAT_R8G8B8A8_SNORM:
1648 case VK_FORMAT_R8G8B8A8_USCALED:
1649 case VK_FORMAT_R8G8B8A8_SSCALED:
1650 case VK_FORMAT_R8G8B8A8_UINT:
1651 case VK_FORMAT_R8G8B8A8_SINT:
1652 case VK_FORMAT_R8G8B8A8_SRGB:
1653 case VK_FORMAT_B8G8R8A8_UNORM:
1654 case VK_FORMAT_B8G8R8A8_SNORM:
1655 case VK_FORMAT_B8G8R8A8_USCALED:
1656 case VK_FORMAT_B8G8R8A8_SSCALED:
1657 case VK_FORMAT_B8G8R8A8_UINT:
1658 case VK_FORMAT_B8G8R8A8_SINT:
1659 case VK_FORMAT_B8G8R8A8_SRGB:
1660 case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
1661 case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
1662 case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
1663 case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
1664 case VK_FORMAT_A8B8G8R8_UINT_PACK32:
1665 case VK_FORMAT_A8B8G8R8_SINT_PACK32:
1666 case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
1667 case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
1668 case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
1669 case VK_FORMAT_A2R10G10B10_USCALED_PACK32:
1670 case VK_FORMAT_A2R10G10B10_SSCALED_PACK32:
1671 case VK_FORMAT_A2R10G10B10_UINT_PACK32:
1672 case VK_FORMAT_A2R10G10B10_SINT_PACK32:
1673 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
1674 case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
1675 case VK_FORMAT_A2B10G10R10_USCALED_PACK32:
1676 case VK_FORMAT_A2B10G10R10_SSCALED_PACK32:
1677 case VK_FORMAT_A2B10G10R10_UINT_PACK32:
1678 case VK_FORMAT_A2B10G10R10_SINT_PACK32:
1679 case VK_FORMAT_R16G16B16A16_UNORM:
1680 case VK_FORMAT_R16G16B16A16_SNORM:
1681 case VK_FORMAT_R16G16B16A16_USCALED:
1682 case VK_FORMAT_R16G16B16A16_SSCALED:
1683 case VK_FORMAT_R16G16B16A16_UINT:
1684 case VK_FORMAT_R16G16B16A16_SINT:
1685 case VK_FORMAT_R16G16B16A16_SFLOAT:
1686 case VK_FORMAT_R32G32B32A32_UINT:
1687 case VK_FORMAT_R32G32B32A32_SINT:
1688 case VK_FORMAT_R32G32B32A32_SFLOAT:
1689 case VK_FORMAT_R64G64B64A64_UINT:
1690 case VK_FORMAT_R64G64B64A64_SINT:
1691 case VK_FORMAT_R64G64B64A64_SFLOAT:
1692 case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
1693 case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
1694 case VK_FORMAT_BC2_UNORM_BLOCK:
1695 case VK_FORMAT_BC2_SRGB_BLOCK:
1696 case VK_FORMAT_BC3_UNORM_BLOCK:
1697 case VK_FORMAT_BC3_SRGB_BLOCK:
1698 case VK_FORMAT_BC7_UNORM_BLOCK:
1699 case VK_FORMAT_BC7_SRGB_BLOCK:
1700 case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
1701 case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
1702 case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
1703 case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
1704 case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
1705 case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
1706 case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
1707 case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
1708 case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
1709 case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
1710 case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
1711 case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
1712 case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
1713 case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
1714 case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
1715 case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
1716 case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
1717 case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
1718 case VK_FORMAT_ASTC_4x4_SRGB_BLOCK:
1719 case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
1720 case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
1721 case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
1722 case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
1723 case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
1724 case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
1725 case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
1726 case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
1727 case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
1728 case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
1729 case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
1730 case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
1731 case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
1732 return 4;
1733 default:
1734 UNSUPPORTED("Format: %d", int(format));
1735 }
1736
1737 return 1;
1738 }
1739
isUnsigned() const1740 bool Format::isUnsigned() const
1741 {
1742 // TODO(b/203068380): create a proper check for signedness
1743 return isUnsignedComponent(0);
1744 }
1745
isUnsignedComponent(int component) const1746 bool Format::isUnsignedComponent(int component) const
1747 {
1748 switch(format)
1749 {
1750 case VK_FORMAT_UNDEFINED:
1751 case VK_FORMAT_R4G4_UNORM_PACK8:
1752 case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
1753 case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
1754 case VK_FORMAT_A4R4G4B4_UNORM_PACK16:
1755 case VK_FORMAT_A4B4G4R4_UNORM_PACK16:
1756 case VK_FORMAT_R5G6B5_UNORM_PACK16:
1757 case VK_FORMAT_B5G6R5_UNORM_PACK16:
1758 case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
1759 case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
1760 case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
1761 case VK_FORMAT_R8_UNORM:
1762 case VK_FORMAT_R8_UINT:
1763 case VK_FORMAT_R8_SRGB:
1764 case VK_FORMAT_R8G8_UNORM:
1765 case VK_FORMAT_R8G8_USCALED:
1766 case VK_FORMAT_R8G8_UINT:
1767 case VK_FORMAT_R8G8_SRGB:
1768 case VK_FORMAT_R8G8B8A8_UNORM:
1769 case VK_FORMAT_R8G8B8A8_USCALED:
1770 case VK_FORMAT_R8G8B8A8_UINT:
1771 case VK_FORMAT_R8G8B8A8_SRGB:
1772 case VK_FORMAT_B8G8R8A8_UNORM:
1773 case VK_FORMAT_B8G8R8A8_USCALED:
1774 case VK_FORMAT_B8G8R8A8_UINT:
1775 case VK_FORMAT_B8G8R8A8_SRGB:
1776 case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
1777 case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
1778 case VK_FORMAT_A8B8G8R8_UINT_PACK32:
1779 case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
1780 case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
1781 case VK_FORMAT_A2R10G10B10_USCALED_PACK32:
1782 case VK_FORMAT_A2R10G10B10_UINT_PACK32:
1783 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
1784 case VK_FORMAT_A2B10G10R10_USCALED_PACK32:
1785 case VK_FORMAT_A2B10G10R10_UINT_PACK32:
1786 case VK_FORMAT_R16_UNORM:
1787 case VK_FORMAT_R16_USCALED:
1788 case VK_FORMAT_R16_UINT:
1789 case VK_FORMAT_R16G16_UNORM:
1790 case VK_FORMAT_R16G16_USCALED:
1791 case VK_FORMAT_R16G16_UINT:
1792 case VK_FORMAT_R16G16B16_UNORM:
1793 case VK_FORMAT_R16G16B16_USCALED:
1794 case VK_FORMAT_R16G16B16_UINT:
1795 case VK_FORMAT_R16G16B16A16_UNORM:
1796 case VK_FORMAT_R16G16B16A16_USCALED:
1797 case VK_FORMAT_R16G16B16A16_UINT:
1798 case VK_FORMAT_R32_UINT:
1799 case VK_FORMAT_R32G32_UINT:
1800 case VK_FORMAT_R32G32B32_UINT:
1801 case VK_FORMAT_R32G32B32A32_UINT:
1802 case VK_FORMAT_R64_UINT:
1803 case VK_FORMAT_R64G64_UINT:
1804 case VK_FORMAT_R64G64B64_UINT:
1805 case VK_FORMAT_R64G64B64A64_UINT:
1806 case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
1807 case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
1808 case VK_FORMAT_D16_UNORM:
1809 case VK_FORMAT_X8_D24_UNORM_PACK32:
1810 case VK_FORMAT_S8_UINT:
1811 case VK_FORMAT_D16_UNORM_S8_UINT:
1812 case VK_FORMAT_D24_UNORM_S8_UINT:
1813 case VK_FORMAT_D32_SFLOAT:
1814 case VK_FORMAT_D32_SFLOAT_S8_UINT:
1815 case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
1816 case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
1817 case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
1818 case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
1819 case VK_FORMAT_BC2_UNORM_BLOCK:
1820 case VK_FORMAT_BC2_SRGB_BLOCK:
1821 case VK_FORMAT_BC3_UNORM_BLOCK:
1822 case VK_FORMAT_BC3_SRGB_BLOCK:
1823 case VK_FORMAT_BC4_UNORM_BLOCK:
1824 case VK_FORMAT_BC5_UNORM_BLOCK:
1825 case VK_FORMAT_BC6H_UFLOAT_BLOCK:
1826 case VK_FORMAT_BC7_UNORM_BLOCK:
1827 case VK_FORMAT_BC7_SRGB_BLOCK:
1828 case VK_FORMAT_EAC_R11_UNORM_BLOCK:
1829 case VK_FORMAT_EAC_R11G11_UNORM_BLOCK:
1830 case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
1831 case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
1832 case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
1833 case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
1834 case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
1835 case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
1836 case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
1837 case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
1838 case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
1839 case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
1840 case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
1841 case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
1842 case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
1843 case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
1844 case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
1845 case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
1846 case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
1847 case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
1848 case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
1849 case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
1850 case VK_FORMAT_ASTC_4x4_SRGB_BLOCK:
1851 case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
1852 case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
1853 case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
1854 case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
1855 case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
1856 case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
1857 case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
1858 case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
1859 case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
1860 case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
1861 case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
1862 case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
1863 case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
1864 return true;
1865 case VK_FORMAT_R8G8B8A8_SNORM:
1866 case VK_FORMAT_R8G8B8A8_SSCALED:
1867 case VK_FORMAT_R8G8B8A8_SINT:
1868 case VK_FORMAT_B8G8R8A8_SNORM:
1869 case VK_FORMAT_B8G8R8A8_SSCALED:
1870 case VK_FORMAT_B8G8R8A8_SINT:
1871 case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
1872 case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
1873 case VK_FORMAT_A8B8G8R8_SINT_PACK32:
1874 case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
1875 case VK_FORMAT_A2R10G10B10_SSCALED_PACK32:
1876 case VK_FORMAT_A2R10G10B10_SINT_PACK32:
1877 case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
1878 case VK_FORMAT_A2B10G10R10_SSCALED_PACK32:
1879 case VK_FORMAT_A2B10G10R10_SINT_PACK32:
1880 case VK_FORMAT_R16G16B16A16_SNORM:
1881 case VK_FORMAT_R16G16B16A16_SSCALED:
1882 case VK_FORMAT_R16G16B16A16_SINT:
1883 case VK_FORMAT_R16G16B16A16_SFLOAT:
1884 case VK_FORMAT_R32G32B32A32_SINT:
1885 case VK_FORMAT_R32G32B32A32_SFLOAT:
1886 case VK_FORMAT_R64G64B64A64_SINT:
1887 case VK_FORMAT_R64G64B64A64_SFLOAT:
1888 case VK_FORMAT_BC4_SNORM_BLOCK:
1889 case VK_FORMAT_BC5_SNORM_BLOCK:
1890 case VK_FORMAT_BC6H_SFLOAT_BLOCK:
1891 case VK_FORMAT_EAC_R11_SNORM_BLOCK:
1892 case VK_FORMAT_EAC_R11G11_SNORM_BLOCK:
1893 // YCbCr formats treated as signed because VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY
1894 // expects chroma components to be in range [-0.5, 0.5]
1895 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
1896 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
1897 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
1898 return false;
1899 case VK_FORMAT_R8_SNORM:
1900 case VK_FORMAT_R8_USCALED:
1901 case VK_FORMAT_R8_SSCALED:
1902 case VK_FORMAT_R8_SINT:
1903 case VK_FORMAT_R16_SNORM:
1904 case VK_FORMAT_R16_SSCALED:
1905 case VK_FORMAT_R16_SINT:
1906 case VK_FORMAT_R16_SFLOAT:
1907 case VK_FORMAT_R32_SINT:
1908 case VK_FORMAT_R32_SFLOAT:
1909 case VK_FORMAT_R64_SINT:
1910 case VK_FORMAT_R64_SFLOAT:
1911 return component >= 1;
1912 case VK_FORMAT_R8G8_SNORM:
1913 case VK_FORMAT_R8G8_SSCALED:
1914 case VK_FORMAT_R8G8_SINT:
1915 case VK_FORMAT_R16G16_SNORM:
1916 case VK_FORMAT_R16G16_SSCALED:
1917 case VK_FORMAT_R16G16_SINT:
1918 case VK_FORMAT_R16G16_SFLOAT:
1919 case VK_FORMAT_R32G32_SINT:
1920 case VK_FORMAT_R32G32_SFLOAT:
1921 case VK_FORMAT_R64G64_SINT:
1922 case VK_FORMAT_R64G64_SFLOAT:
1923 return component >= 2;
1924 case VK_FORMAT_R16G16B16_SNORM:
1925 case VK_FORMAT_R16G16B16_SSCALED:
1926 case VK_FORMAT_R16G16B16_SINT:
1927 case VK_FORMAT_R16G16B16_SFLOAT:
1928 case VK_FORMAT_R32G32B32_SINT:
1929 case VK_FORMAT_R32G32B32_SFLOAT:
1930 case VK_FORMAT_R64G64B64_SINT:
1931 case VK_FORMAT_R64G64B64_SFLOAT:
1932 return component >= 3;
1933 default:
1934 UNSUPPORTED("Format: %d", int(format));
1935 }
1936
1937 return false;
1938 }
1939
bytes() const1940 size_t Format::bytes() const
1941 {
1942 switch(format)
1943 {
1944 case VK_FORMAT_UNDEFINED:
1945 return 0;
1946 case VK_FORMAT_R4G4_UNORM_PACK8:
1947 return 1;
1948 case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
1949 case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
1950 case VK_FORMAT_A4R4G4B4_UNORM_PACK16:
1951 case VK_FORMAT_A4B4G4R4_UNORM_PACK16:
1952 case VK_FORMAT_R5G6B5_UNORM_PACK16:
1953 case VK_FORMAT_B5G6R5_UNORM_PACK16:
1954 case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
1955 case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
1956 case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
1957 return 2;
1958 case VK_FORMAT_R8_UNORM:
1959 case VK_FORMAT_R8_SNORM:
1960 case VK_FORMAT_R8_USCALED:
1961 case VK_FORMAT_R8_SSCALED:
1962 case VK_FORMAT_R8_UINT:
1963 case VK_FORMAT_R8_SINT:
1964 case VK_FORMAT_R8_SRGB:
1965 return 1;
1966 case VK_FORMAT_R8G8_UNORM:
1967 case VK_FORMAT_R8G8_SNORM:
1968 case VK_FORMAT_R8G8_USCALED:
1969 case VK_FORMAT_R8G8_SSCALED:
1970 case VK_FORMAT_R8G8_UINT:
1971 case VK_FORMAT_R8G8_SINT:
1972 case VK_FORMAT_R8G8_SRGB:
1973 case VK_FORMAT_R10X6_UNORM_PACK16:
1974 return 2;
1975 case VK_FORMAT_R8G8B8A8_UNORM:
1976 case VK_FORMAT_R8G8B8A8_SNORM:
1977 case VK_FORMAT_R8G8B8A8_USCALED:
1978 case VK_FORMAT_R8G8B8A8_SSCALED:
1979 case VK_FORMAT_R8G8B8A8_UINT:
1980 case VK_FORMAT_R8G8B8A8_SINT:
1981 case VK_FORMAT_R8G8B8A8_SRGB:
1982 case VK_FORMAT_B8G8R8A8_UNORM:
1983 case VK_FORMAT_B8G8R8A8_SNORM:
1984 case VK_FORMAT_B8G8R8A8_USCALED:
1985 case VK_FORMAT_B8G8R8A8_SSCALED:
1986 case VK_FORMAT_B8G8R8A8_UINT:
1987 case VK_FORMAT_B8G8R8A8_SINT:
1988 case VK_FORMAT_B8G8R8A8_SRGB:
1989 case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
1990 case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
1991 case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
1992 case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
1993 case VK_FORMAT_A8B8G8R8_UINT_PACK32:
1994 case VK_FORMAT_A8B8G8R8_SINT_PACK32:
1995 case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
1996 case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
1997 case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
1998 case VK_FORMAT_A2R10G10B10_USCALED_PACK32:
1999 case VK_FORMAT_A2R10G10B10_SSCALED_PACK32:
2000 case VK_FORMAT_A2R10G10B10_UINT_PACK32:
2001 case VK_FORMAT_A2R10G10B10_SINT_PACK32:
2002 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
2003 case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
2004 case VK_FORMAT_A2B10G10R10_USCALED_PACK32:
2005 case VK_FORMAT_A2B10G10R10_SSCALED_PACK32:
2006 case VK_FORMAT_A2B10G10R10_UINT_PACK32:
2007 case VK_FORMAT_A2B10G10R10_SINT_PACK32:
2008 case VK_FORMAT_R10X6G10X6_UNORM_2PACK16:
2009 return 4;
2010 case VK_FORMAT_R16_UNORM:
2011 case VK_FORMAT_R16_SNORM:
2012 case VK_FORMAT_R16_USCALED:
2013 case VK_FORMAT_R16_SSCALED:
2014 case VK_FORMAT_R16_UINT:
2015 case VK_FORMAT_R16_SINT:
2016 case VK_FORMAT_R16_SFLOAT:
2017 return 2;
2018 case VK_FORMAT_R16G16_UNORM:
2019 case VK_FORMAT_R16G16_SNORM:
2020 case VK_FORMAT_R16G16_USCALED:
2021 case VK_FORMAT_R16G16_SSCALED:
2022 case VK_FORMAT_R16G16_UINT:
2023 case VK_FORMAT_R16G16_SINT:
2024 case VK_FORMAT_R16G16_SFLOAT:
2025 return 4;
2026 case VK_FORMAT_R16G16B16_UNORM:
2027 case VK_FORMAT_R16G16B16_SNORM:
2028 case VK_FORMAT_R16G16B16_USCALED:
2029 case VK_FORMAT_R16G16B16_SSCALED:
2030 case VK_FORMAT_R16G16B16_UINT:
2031 case VK_FORMAT_R16G16B16_SINT:
2032 case VK_FORMAT_R16G16B16_SFLOAT:
2033 return 6;
2034 case VK_FORMAT_R16G16B16A16_UNORM:
2035 case VK_FORMAT_R16G16B16A16_SNORM:
2036 case VK_FORMAT_R16G16B16A16_USCALED:
2037 case VK_FORMAT_R16G16B16A16_SSCALED:
2038 case VK_FORMAT_R16G16B16A16_UINT:
2039 case VK_FORMAT_R16G16B16A16_SINT:
2040 case VK_FORMAT_R16G16B16A16_SFLOAT:
2041 return 8;
2042 case VK_FORMAT_R32_UINT:
2043 case VK_FORMAT_R32_SINT:
2044 case VK_FORMAT_R32_SFLOAT:
2045 return 4;
2046 case VK_FORMAT_R32G32_UINT:
2047 case VK_FORMAT_R32G32_SINT:
2048 case VK_FORMAT_R32G32_SFLOAT:
2049 return 8;
2050 case VK_FORMAT_R32G32B32_UINT:
2051 case VK_FORMAT_R32G32B32_SINT:
2052 case VK_FORMAT_R32G32B32_SFLOAT:
2053 return 12;
2054 case VK_FORMAT_R32G32B32A32_UINT:
2055 case VK_FORMAT_R32G32B32A32_SINT:
2056 case VK_FORMAT_R32G32B32A32_SFLOAT:
2057 return 16;
2058 case VK_FORMAT_R64_UINT:
2059 case VK_FORMAT_R64_SINT:
2060 case VK_FORMAT_R64_SFLOAT:
2061 return 8;
2062 case VK_FORMAT_R64G64_UINT:
2063 case VK_FORMAT_R64G64_SINT:
2064 case VK_FORMAT_R64G64_SFLOAT:
2065 return 16;
2066 case VK_FORMAT_R64G64B64_UINT:
2067 case VK_FORMAT_R64G64B64_SINT:
2068 case VK_FORMAT_R64G64B64_SFLOAT:
2069 return 24;
2070 case VK_FORMAT_R64G64B64A64_UINT:
2071 case VK_FORMAT_R64G64B64A64_SINT:
2072 case VK_FORMAT_R64G64B64A64_SFLOAT:
2073 return 32;
2074 case VK_FORMAT_B10G11R11_UFLOAT_PACK32: return 4;
2075 case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: return 4;
2076 case VK_FORMAT_D16_UNORM: return 2;
2077 case VK_FORMAT_X8_D24_UNORM_PACK32: return 4;
2078 case VK_FORMAT_D32_SFLOAT: return 4;
2079 case VK_FORMAT_S8_UINT: return 1;
2080 case VK_FORMAT_D16_UNORM_S8_UINT: return 2; // Separate depth and stencil planes // TODO: ASSERT to ensure this is only called per-aspect?
2081 case VK_FORMAT_D24_UNORM_S8_UINT: return 4; // Combined depth and stencil planes // TODO: ASSERT to ensure this is only called per-aspect?
2082 case VK_FORMAT_D32_SFLOAT_S8_UINT:
2083 return 4; // Separate depth and stencil planes // TODO: ASSERT to ensure this is only called per-aspect?
2084 // Note: Compressed formats don't return bytes per pixel,
2085 // since these would be fractional. The returned value
2086 // is bytes per pixel for 1 column, so 2 for 64 bit 4x4
2087 // blocks and 4 for 128 bit 4x4 blocks.
2088 case VK_FORMAT_BC1_RGB_UNORM_BLOCK: return 2;
2089 case VK_FORMAT_BC1_RGB_SRGB_BLOCK: return 2;
2090 case VK_FORMAT_BC1_RGBA_UNORM_BLOCK: return 2;
2091 case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: return 2;
2092 case VK_FORMAT_BC2_UNORM_BLOCK: return 4;
2093 case VK_FORMAT_BC2_SRGB_BLOCK: return 4;
2094 case VK_FORMAT_BC3_UNORM_BLOCK: return 4;
2095 case VK_FORMAT_BC3_SRGB_BLOCK: return 4;
2096 case VK_FORMAT_BC4_UNORM_BLOCK: return 2;
2097 case VK_FORMAT_BC4_SNORM_BLOCK: return 2;
2098 case VK_FORMAT_BC5_UNORM_BLOCK: return 4;
2099 case VK_FORMAT_BC5_SNORM_BLOCK: return 4;
2100 case VK_FORMAT_BC6H_UFLOAT_BLOCK: return 4;
2101 case VK_FORMAT_BC6H_SFLOAT_BLOCK: return 4;
2102 case VK_FORMAT_BC7_UNORM_BLOCK: return 4;
2103 case VK_FORMAT_BC7_SRGB_BLOCK: return 4;
2104 case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: return 2;
2105 case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: return 2;
2106 case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: return 2;
2107 case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: return 2;
2108 case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: return 4;
2109 case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: return 4;
2110 case VK_FORMAT_EAC_R11_UNORM_BLOCK: return 2;
2111 case VK_FORMAT_EAC_R11_SNORM_BLOCK: return 2;
2112 case VK_FORMAT_EAC_R11G11_UNORM_BLOCK: return 4;
2113 case VK_FORMAT_EAC_R11G11_SNORM_BLOCK: return 4;
2114 case VK_FORMAT_ASTC_4x4_UNORM_BLOCK: return 4;
2115 case VK_FORMAT_ASTC_4x4_SRGB_BLOCK: return 4;
2116 case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
2117 case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
2118 case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
2119 case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
2120 case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
2121 case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
2122 case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
2123 case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
2124 case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
2125 case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
2126 case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
2127 case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
2128 case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
2129 case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
2130 case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
2131 case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
2132 case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
2133 case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
2134 case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
2135 case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
2136 case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
2137 case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
2138 case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
2139 case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
2140 case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
2141 case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
2142 UNSUPPORTED("format: %d", int(format));
2143 return 0;
2144 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
2145 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
2146 // TODO: ASSERT to ensure this is only called per-aspect?
2147 return 1; // Y plane only
2148 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
2149 // TODO: ASSERT to ensure this is only called per-aspect?
2150 return 2; // Y plane only
2151 default:
2152 UNSUPPORTED("Format: %d", int(format));
2153 }
2154
2155 return 0;
2156 }
2157
pitchB(int width,int border) const2158 size_t Format::pitchB(int width, int border) const
2159 {
2160 // Render targets require 2x2 quads
2161 width = sw::align<2>(width + 2 * border);
2162
2163 switch(format)
2164 {
2165 case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
2166 case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
2167 case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
2168 case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
2169 case VK_FORMAT_BC4_UNORM_BLOCK:
2170 case VK_FORMAT_BC4_SNORM_BLOCK:
2171 case VK_FORMAT_EAC_R11_UNORM_BLOCK:
2172 case VK_FORMAT_EAC_R11_SNORM_BLOCK:
2173 case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
2174 case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
2175 case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
2176 case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
2177 return 8 * ((width + 3) / 4); // 64 bit per 4x4 block, computed per 4 rows
2178 case VK_FORMAT_BC2_UNORM_BLOCK:
2179 case VK_FORMAT_BC2_SRGB_BLOCK:
2180 case VK_FORMAT_BC3_UNORM_BLOCK:
2181 case VK_FORMAT_BC3_SRGB_BLOCK:
2182 case VK_FORMAT_BC5_UNORM_BLOCK:
2183 case VK_FORMAT_BC5_SNORM_BLOCK:
2184 case VK_FORMAT_BC6H_UFLOAT_BLOCK:
2185 case VK_FORMAT_BC6H_SFLOAT_BLOCK:
2186 case VK_FORMAT_BC7_UNORM_BLOCK:
2187 case VK_FORMAT_BC7_SRGB_BLOCK:
2188 case VK_FORMAT_EAC_R11G11_UNORM_BLOCK:
2189 case VK_FORMAT_EAC_R11G11_SNORM_BLOCK:
2190 case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
2191 case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
2192 case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
2193 case VK_FORMAT_ASTC_4x4_SRGB_BLOCK:
2194 return 16 * ((width + 3) / 4); // 128 bit per 4x4 block, computed per 4 rows
2195 case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
2196 case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
2197 case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
2198 case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
2199 return 16 * ((width + 4) / 5);
2200 case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
2201 case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
2202 case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
2203 case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
2204 return 16 * ((width + 5) / 6);
2205 case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
2206 case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
2207 case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
2208 case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
2209 case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
2210 case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
2211 return 16 * ((width + 7) / 8);
2212 case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
2213 case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
2214 case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
2215 case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
2216 case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
2217 case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
2218 case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
2219 case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
2220 return 16 * ((width + 9) / 10);
2221 case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
2222 case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
2223 case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
2224 case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
2225 return 16 * ((width + 11) / 12);
2226 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
2227 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
2228 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
2229 return sw::align<16>(width); // Y plane only // TODO: ASSERT to ensure this is only called per-aspect?
2230 default:
2231 return bytes() * width;
2232 }
2233 }
2234
sliceBUnpadded(int width,int height,int border) const2235 size_t Format::sliceBUnpadded(int width, int height, int border) const
2236 {
2237 // Render targets require 2x2 quads
2238 height = sw::align<2>(height + 2 * border);
2239
2240 switch(format)
2241 {
2242 case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
2243 case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
2244 case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
2245 case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
2246 case VK_FORMAT_BC2_UNORM_BLOCK:
2247 case VK_FORMAT_BC2_SRGB_BLOCK:
2248 case VK_FORMAT_BC3_UNORM_BLOCK:
2249 case VK_FORMAT_BC3_SRGB_BLOCK:
2250 case VK_FORMAT_BC4_UNORM_BLOCK:
2251 case VK_FORMAT_BC4_SNORM_BLOCK:
2252 case VK_FORMAT_BC5_UNORM_BLOCK:
2253 case VK_FORMAT_BC5_SNORM_BLOCK:
2254 case VK_FORMAT_EAC_R11_UNORM_BLOCK:
2255 case VK_FORMAT_EAC_R11_SNORM_BLOCK:
2256 case VK_FORMAT_EAC_R11G11_UNORM_BLOCK:
2257 case VK_FORMAT_EAC_R11G11_SNORM_BLOCK:
2258 case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
2259 case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
2260 case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
2261 case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
2262 case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
2263 case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
2264 case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
2265 case VK_FORMAT_ASTC_4x4_SRGB_BLOCK:
2266 case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
2267 case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
2268 return pitchB(width, border) * ((height + 3) / 4); // Pitch computed per 4 rows
2269 case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
2270 case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
2271 case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
2272 case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
2273 case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
2274 case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
2275 case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
2276 case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
2277 return pitchB(width, border) * ((height + 4) / 5); // Pitch computed per 5 rows
2278 case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
2279 case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
2280 case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
2281 case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
2282 case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
2283 case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
2284 return pitchB(width, border) * ((height + 5) / 6); // Pitch computed per 6 rows
2285 case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
2286 case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
2287 case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
2288 case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
2289 return pitchB(width, border) * ((height + 7) / 8); // Pitch computed per 8 rows
2290 case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
2291 case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
2292 case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
2293 case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
2294 return pitchB(width, border) * ((height + 9) / 10); // Pitch computed per 10 rows
2295 case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
2296 case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
2297 return pitchB(width, border) * ((height + 11) / 12); // Pitch computed per 12 rows
2298 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
2299 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
2300 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
2301 // "Images in this format must be defined with a width and height that is a multiple of two."
2302 return pitchB(width, border) * (height + height / 2); // U and V planes are 1/4 size of Y plane.
2303 default:
2304 return pitchB(width, border) * height; // Pitch computed per row
2305 }
2306 }
2307
sliceB(int width,int height,int border) const2308 size_t Format::sliceB(int width, int height, int border) const
2309 {
2310 return sw::align<16>(sliceBUnpadded(width, height, border));
2311 }
2312
getScale() const2313 sw::float4 Format::getScale() const
2314 {
2315 switch(format)
2316 {
2317 case VK_FORMAT_R4G4_UNORM_PACK8:
2318 case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
2319 case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
2320 case VK_FORMAT_A4R4G4B4_UNORM_PACK16:
2321 case VK_FORMAT_A4B4G4R4_UNORM_PACK16:
2322 return sw::float4(0xF, 0xF, 0xF, 0xF);
2323 case VK_FORMAT_R8_UNORM:
2324 case VK_FORMAT_R8G8_UNORM:
2325 case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
2326 case VK_FORMAT_R8G8B8A8_UNORM:
2327 case VK_FORMAT_B8G8R8A8_UNORM:
2328 case VK_FORMAT_R8_SRGB:
2329 case VK_FORMAT_R8G8_SRGB:
2330 case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
2331 case VK_FORMAT_R8G8B8A8_SRGB:
2332 case VK_FORMAT_B8G8R8A8_SRGB:
2333 return sw::float4(0xFF, 0xFF, 0xFF, 0xFF);
2334 case VK_FORMAT_R8_SNORM:
2335 case VK_FORMAT_R8G8_SNORM:
2336 case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
2337 case VK_FORMAT_R8G8B8A8_SNORM:
2338 case VK_FORMAT_B8G8R8A8_SNORM:
2339 return sw::float4(0x7F, 0x7F, 0x7F, 0x7F);
2340 case VK_FORMAT_R16_UNORM:
2341 case VK_FORMAT_R16G16_UNORM:
2342 case VK_FORMAT_R16G16B16_UNORM:
2343 case VK_FORMAT_R16G16B16A16_UNORM:
2344 return sw::float4(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF);
2345 case VK_FORMAT_R16_SNORM:
2346 case VK_FORMAT_R16G16_SNORM:
2347 case VK_FORMAT_R16G16B16_SNORM:
2348 case VK_FORMAT_R16G16B16A16_SNORM:
2349 return sw::float4(0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF);
2350 case VK_FORMAT_R8_SINT:
2351 case VK_FORMAT_R8_UINT:
2352 case VK_FORMAT_R8G8_SINT:
2353 case VK_FORMAT_R8G8_UINT:
2354 case VK_FORMAT_R8G8B8A8_SINT:
2355 case VK_FORMAT_R8G8B8A8_UINT:
2356 case VK_FORMAT_A8B8G8R8_SINT_PACK32:
2357 case VK_FORMAT_A8B8G8R8_UINT_PACK32:
2358 case VK_FORMAT_B8G8R8A8_SINT:
2359 case VK_FORMAT_B8G8R8A8_UINT:
2360 case VK_FORMAT_R8_USCALED:
2361 case VK_FORMAT_R8G8_USCALED:
2362 case VK_FORMAT_R8G8B8A8_USCALED:
2363 case VK_FORMAT_B8G8R8A8_USCALED:
2364 case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
2365 case VK_FORMAT_R8_SSCALED:
2366 case VK_FORMAT_R8G8_SSCALED:
2367 case VK_FORMAT_R8G8B8A8_SSCALED:
2368 case VK_FORMAT_B8G8R8A8_SSCALED:
2369 case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
2370 case VK_FORMAT_R16_SINT:
2371 case VK_FORMAT_R16_UINT:
2372 case VK_FORMAT_R16G16_SINT:
2373 case VK_FORMAT_R16G16_UINT:
2374 case VK_FORMAT_R16G16B16A16_SINT:
2375 case VK_FORMAT_R16G16B16A16_UINT:
2376 case VK_FORMAT_R16_SSCALED:
2377 case VK_FORMAT_R16G16_SSCALED:
2378 case VK_FORMAT_R16G16B16_SSCALED:
2379 case VK_FORMAT_R16G16B16A16_SSCALED:
2380 case VK_FORMAT_R16_USCALED:
2381 case VK_FORMAT_R16G16_USCALED:
2382 case VK_FORMAT_R16G16B16_USCALED:
2383 case VK_FORMAT_R16G16B16A16_USCALED:
2384 case VK_FORMAT_R32_SINT:
2385 case VK_FORMAT_R32_UINT:
2386 case VK_FORMAT_R32G32_SINT:
2387 case VK_FORMAT_R32G32_UINT:
2388 case VK_FORMAT_R32G32B32_SINT:
2389 case VK_FORMAT_R32G32B32_UINT:
2390 case VK_FORMAT_R32G32B32A32_SINT:
2391 case VK_FORMAT_R32G32B32A32_UINT:
2392 case VK_FORMAT_R32G32B32A32_SFLOAT:
2393 case VK_FORMAT_R32G32B32_SFLOAT:
2394 case VK_FORMAT_R32G32_SFLOAT:
2395 case VK_FORMAT_R32_SFLOAT:
2396 case VK_FORMAT_R16G16B16A16_SFLOAT:
2397 case VK_FORMAT_R16G16B16_SFLOAT:
2398 case VK_FORMAT_R16G16_SFLOAT:
2399 case VK_FORMAT_R16_SFLOAT:
2400 case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
2401 case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
2402 case VK_FORMAT_A2R10G10B10_USCALED_PACK32:
2403 case VK_FORMAT_A2R10G10B10_SSCALED_PACK32:
2404 case VK_FORMAT_A2R10G10B10_UINT_PACK32:
2405 case VK_FORMAT_A2R10G10B10_SINT_PACK32:
2406 case VK_FORMAT_A2B10G10R10_USCALED_PACK32:
2407 case VK_FORMAT_A2B10G10R10_SSCALED_PACK32:
2408 case VK_FORMAT_A2B10G10R10_UINT_PACK32:
2409 case VK_FORMAT_A2B10G10R10_SINT_PACK32:
2410 return sw::float4(1.0f, 1.0f, 1.0f, 1.0f);
2411 case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
2412 case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
2413 case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
2414 return sw::float4(0x1F, 0x1F, 0x1F, 0x01);
2415 case VK_FORMAT_R5G6B5_UNORM_PACK16:
2416 case VK_FORMAT_B5G6R5_UNORM_PACK16:
2417 return sw::float4(0x1F, 0x3F, 0x1F, 1.0f);
2418 case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
2419 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
2420 return sw::float4(0x3FF, 0x3FF, 0x3FF, 0x03);
2421 case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
2422 case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
2423 return sw::float4(0x1FF, 0x1FF, 0x1FF, 0x01);
2424 case VK_FORMAT_D16_UNORM:
2425 return sw::float4(0xFFFF, 0.0f, 0.0f, 0.0f);
2426 case VK_FORMAT_D24_UNORM_S8_UINT:
2427 case VK_FORMAT_X8_D24_UNORM_PACK32:
2428 return sw::float4(0xFFFFFF, 0.0f, 0.0f, 0.0f);
2429 case VK_FORMAT_D32_SFLOAT:
2430 case VK_FORMAT_D32_SFLOAT_S8_UINT:
2431 case VK_FORMAT_S8_UINT:
2432 return sw::float4(1.0f, 1.0f, 1.0f, 1.0f);
2433 default:
2434 UNSUPPORTED("format %d", int(format));
2435 break;
2436 }
2437
2438 return sw::float4(1.0f, 1.0f, 1.0f, 1.0f);
2439 }
2440
bitsPerComponent() const2441 sw::int4 Format::bitsPerComponent() const
2442 {
2443 switch(format)
2444 {
2445 case VK_FORMAT_R4G4_UNORM_PACK8:
2446 return sw::int4(4, 4, 0, 0);
2447 case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
2448 case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
2449 case VK_FORMAT_A4R4G4B4_UNORM_PACK16:
2450 case VK_FORMAT_A4B4G4R4_UNORM_PACK16:
2451 return sw::int4(4, 4, 4, 4);
2452 case VK_FORMAT_R8_UNORM:
2453 case VK_FORMAT_R8_SNORM:
2454 case VK_FORMAT_R8_SRGB:
2455 case VK_FORMAT_R8_SINT:
2456 case VK_FORMAT_R8_UINT:
2457 case VK_FORMAT_R8_USCALED:
2458 case VK_FORMAT_R8_SSCALED:
2459 case VK_FORMAT_S8_UINT:
2460 return sw::int4(8, 0, 0, 0);
2461 case VK_FORMAT_R8G8_SRGB:
2462 case VK_FORMAT_R8G8_UNORM:
2463 case VK_FORMAT_R8G8_SNORM:
2464 case VK_FORMAT_R8G8_SINT:
2465 case VK_FORMAT_R8G8_UINT:
2466 case VK_FORMAT_R8G8_USCALED:
2467 case VK_FORMAT_R8G8_SSCALED:
2468 return sw::int4(8, 8, 0, 0);
2469 case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
2470 case VK_FORMAT_R8G8B8A8_UNORM:
2471 case VK_FORMAT_B8G8R8A8_UNORM:
2472 case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
2473 case VK_FORMAT_R8G8B8A8_SRGB:
2474 case VK_FORMAT_B8G8R8A8_SRGB:
2475 case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
2476 case VK_FORMAT_R8G8B8A8_SNORM:
2477 case VK_FORMAT_B8G8R8A8_SNORM:
2478 case VK_FORMAT_R8G8B8A8_SINT:
2479 case VK_FORMAT_R8G8B8A8_UINT:
2480 case VK_FORMAT_A8B8G8R8_SINT_PACK32:
2481 case VK_FORMAT_A8B8G8R8_UINT_PACK32:
2482 case VK_FORMAT_B8G8R8A8_SINT:
2483 case VK_FORMAT_B8G8R8A8_UINT:
2484 case VK_FORMAT_R8G8B8A8_USCALED:
2485 case VK_FORMAT_B8G8R8A8_USCALED:
2486 case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
2487 case VK_FORMAT_R8G8B8A8_SSCALED:
2488 case VK_FORMAT_B8G8R8A8_SSCALED:
2489 case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
2490 return sw::int4(8, 8, 8, 8);
2491 case VK_FORMAT_R16_UNORM:
2492 case VK_FORMAT_R16_SNORM:
2493 case VK_FORMAT_R16_SINT:
2494 case VK_FORMAT_R16_UINT:
2495 case VK_FORMAT_R16_SSCALED:
2496 case VK_FORMAT_R16_USCALED:
2497 case VK_FORMAT_R16_SFLOAT:
2498 case VK_FORMAT_D16_UNORM:
2499 return sw::int4(16, 0, 0, 0);
2500 case VK_FORMAT_R16G16_UNORM:
2501 case VK_FORMAT_R16G16_SNORM:
2502 case VK_FORMAT_R16G16_SINT:
2503 case VK_FORMAT_R16G16_UINT:
2504 case VK_FORMAT_R16G16_SSCALED:
2505 case VK_FORMAT_R16G16_USCALED:
2506 case VK_FORMAT_R16G16_SFLOAT:
2507 return sw::int4(16, 16, 0, 0);
2508 case VK_FORMAT_R16G16B16_UNORM:
2509 case VK_FORMAT_R16G16B16_SNORM:
2510 case VK_FORMAT_R16G16B16_SSCALED:
2511 case VK_FORMAT_R16G16B16_USCALED:
2512 case VK_FORMAT_R16G16B16_SFLOAT:
2513 return sw::int4(16, 16, 16, 0);
2514 case VK_FORMAT_R16G16B16A16_UNORM:
2515 case VK_FORMAT_R16G16B16A16_SNORM:
2516 case VK_FORMAT_R16G16B16A16_SINT:
2517 case VK_FORMAT_R16G16B16A16_UINT:
2518 case VK_FORMAT_R16G16B16A16_SSCALED:
2519 case VK_FORMAT_R16G16B16A16_USCALED:
2520 case VK_FORMAT_R16G16B16A16_SFLOAT:
2521 return sw::int4(16, 16, 16, 16);
2522 case VK_FORMAT_D24_UNORM_S8_UINT:
2523 case VK_FORMAT_X8_D24_UNORM_PACK32:
2524 return sw::int4(24, 0, 0, 0);
2525 case VK_FORMAT_R32_SINT:
2526 case VK_FORMAT_R32_UINT:
2527 case VK_FORMAT_R32_SFLOAT:
2528 case VK_FORMAT_D32_SFLOAT:
2529 case VK_FORMAT_D32_SFLOAT_S8_UINT:
2530 return sw::int4(32, 0, 0, 0);
2531 case VK_FORMAT_R32G32_SINT:
2532 case VK_FORMAT_R32G32_UINT:
2533 case VK_FORMAT_R32G32_SFLOAT:
2534 return sw::int4(32, 32, 0, 0);
2535 case VK_FORMAT_R32G32B32_SINT:
2536 case VK_FORMAT_R32G32B32_UINT:
2537 case VK_FORMAT_R32G32B32_SFLOAT:
2538 return sw::int4(32, 32, 32, 0);
2539 case VK_FORMAT_R32G32B32A32_SINT:
2540 case VK_FORMAT_R32G32B32A32_UINT:
2541 case VK_FORMAT_R32G32B32A32_SFLOAT:
2542 return sw::int4(32, 32, 32, 32);
2543 case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
2544 return sw::int4(11, 11, 10, 0);
2545 case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
2546 return sw::int4(9, 9, 9, 0);
2547 case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
2548 case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
2549 case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
2550 return sw::int4(5, 5, 5, 1);
2551 case VK_FORMAT_R5G6B5_UNORM_PACK16:
2552 case VK_FORMAT_B5G6R5_UNORM_PACK16:
2553 return sw::int4(5, 6, 5, 0);
2554 case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
2555 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
2556 case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
2557 case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
2558 case VK_FORMAT_A2R10G10B10_USCALED_PACK32:
2559 case VK_FORMAT_A2R10G10B10_SSCALED_PACK32:
2560 case VK_FORMAT_A2R10G10B10_UINT_PACK32:
2561 case VK_FORMAT_A2R10G10B10_SINT_PACK32:
2562 case VK_FORMAT_A2B10G10R10_USCALED_PACK32:
2563 case VK_FORMAT_A2B10G10R10_SSCALED_PACK32:
2564 case VK_FORMAT_A2B10G10R10_UINT_PACK32:
2565 case VK_FORMAT_A2B10G10R10_SINT_PACK32:
2566 return sw::int4(10, 10, 10, 2);
2567 default:
2568 UNSUPPORTED("format %d", int(format));
2569 break;
2570 }
2571
2572 return sw::int4(0, 0, 0, 0);
2573 }
2574
supportsColorAttachmentBlend() const2575 bool Format::supportsColorAttachmentBlend() const
2576 {
2577 switch(format)
2578 {
2579 // Vulkan 1.1 mandatory
2580 case VK_FORMAT_R5G6B5_UNORM_PACK16:
2581 case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
2582 case VK_FORMAT_R8_UNORM:
2583 case VK_FORMAT_R8G8_UNORM:
2584 case VK_FORMAT_R8G8B8A8_UNORM:
2585 case VK_FORMAT_R8G8B8A8_SRGB:
2586 case VK_FORMAT_B8G8R8A8_UNORM:
2587 case VK_FORMAT_B8G8R8A8_SRGB:
2588 case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
2589 case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
2590 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
2591 case VK_FORMAT_R16_SFLOAT:
2592 case VK_FORMAT_R16G16_SFLOAT:
2593 case VK_FORMAT_R16G16B16A16_SFLOAT:
2594 // Optional
2595 case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
2596 case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
2597 case VK_FORMAT_B5G6R5_UNORM_PACK16:
2598 case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
2599 case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
2600 case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
2601 case VK_FORMAT_R16_UNORM:
2602 case VK_FORMAT_R16G16_UNORM:
2603 case VK_FORMAT_R16G16B16A16_UNORM:
2604 case VK_FORMAT_R32_SFLOAT:
2605 case VK_FORMAT_R32G32_SFLOAT:
2606 case VK_FORMAT_R32G32B32A32_SFLOAT:
2607 case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
2608 case VK_FORMAT_A4R4G4B4_UNORM_PACK16:
2609 case VK_FORMAT_A4B4G4R4_UNORM_PACK16:
2610 return true;
2611 default:
2612 return false;
2613 }
2614 }
2615
has16bitPackedTextureFormat() const2616 bool Format::has16bitPackedTextureFormat() const
2617 {
2618 if(bytes() != 2)
2619 {
2620 return false;
2621 }
2622
2623 switch(format)
2624 {
2625 case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
2626 case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
2627 case VK_FORMAT_A4R4G4B4_UNORM_PACK16:
2628 case VK_FORMAT_A4B4G4R4_UNORM_PACK16:
2629 case VK_FORMAT_R5G6B5_UNORM_PACK16:
2630 case VK_FORMAT_B5G6R5_UNORM_PACK16:
2631 case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
2632 case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
2633 case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
2634 return true;
2635 case VK_FORMAT_R8G8_SINT:
2636 case VK_FORMAT_R8G8_UINT:
2637 case VK_FORMAT_R8G8_UNORM:
2638 case VK_FORMAT_R8G8_SNORM:
2639 case VK_FORMAT_R8G8_SRGB:
2640 case VK_FORMAT_R16_UNORM:
2641 case VK_FORMAT_R16_SNORM:
2642 case VK_FORMAT_R16_SINT:
2643 case VK_FORMAT_R16_UINT:
2644 case VK_FORMAT_R16_SFLOAT:
2645 case VK_FORMAT_D16_UNORM:
2646 return false;
2647 default:
2648 UNSUPPORTED("Format: %d", int(format));
2649 }
2650
2651 return false;
2652 }
2653
has8bitTextureComponents() const2654 bool Format::has8bitTextureComponents() const
2655 {
2656 switch(format)
2657 {
2658 case VK_FORMAT_R8_UNORM:
2659 case VK_FORMAT_R8_SNORM:
2660 case VK_FORMAT_R8_UINT:
2661 case VK_FORMAT_R8_SINT:
2662 case VK_FORMAT_R8_SRGB:
2663 case VK_FORMAT_R8G8_UNORM:
2664 case VK_FORMAT_R8G8_SNORM:
2665 case VK_FORMAT_R8G8_UINT:
2666 case VK_FORMAT_R8G8_SINT:
2667 case VK_FORMAT_R8G8_SRGB:
2668 case VK_FORMAT_R8G8B8A8_UNORM:
2669 case VK_FORMAT_R8G8B8A8_SNORM:
2670 case VK_FORMAT_R8G8B8A8_UINT:
2671 case VK_FORMAT_R8G8B8A8_SINT:
2672 case VK_FORMAT_R8G8B8A8_SRGB:
2673 case VK_FORMAT_B8G8R8A8_UNORM:
2674 case VK_FORMAT_B8G8R8A8_SNORM:
2675 case VK_FORMAT_B8G8R8A8_UINT:
2676 case VK_FORMAT_B8G8R8A8_SINT:
2677 case VK_FORMAT_B8G8R8A8_SRGB:
2678 case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
2679 case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
2680 case VK_FORMAT_A8B8G8R8_UINT_PACK32:
2681 case VK_FORMAT_A8B8G8R8_SINT_PACK32:
2682 case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
2683 case VK_FORMAT_S8_UINT:
2684 return true;
2685 case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
2686 case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
2687 case VK_FORMAT_R5G6B5_UNORM_PACK16:
2688 case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
2689 case VK_FORMAT_A4B4G4R4_UNORM_PACK16:
2690 case VK_FORMAT_A4R4G4B4_UNORM_PACK16:
2691 case VK_FORMAT_B5G6R5_UNORM_PACK16:
2692 case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
2693 case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
2694 case VK_FORMAT_R32_SFLOAT:
2695 case VK_FORMAT_R32G32_SFLOAT:
2696 case VK_FORMAT_R32G32B32A32_SFLOAT:
2697 case VK_FORMAT_R16_UNORM:
2698 case VK_FORMAT_R16_SNORM:
2699 case VK_FORMAT_R16G16_UNORM:
2700 case VK_FORMAT_R16G16_SNORM:
2701 case VK_FORMAT_R16G16B16A16_UNORM:
2702 case VK_FORMAT_R16G16B16A16_SNORM:
2703 case VK_FORMAT_R32_SINT:
2704 case VK_FORMAT_R32_UINT:
2705 case VK_FORMAT_R32G32_SINT:
2706 case VK_FORMAT_R32G32_UINT:
2707 case VK_FORMAT_R32G32B32A32_SINT:
2708 case VK_FORMAT_R32G32B32A32_UINT:
2709 case VK_FORMAT_R16_SINT:
2710 case VK_FORMAT_R16_UINT:
2711 case VK_FORMAT_R16_SFLOAT:
2712 case VK_FORMAT_R16G16_SINT:
2713 case VK_FORMAT_R16G16_UINT:
2714 case VK_FORMAT_R16G16_SFLOAT:
2715 case VK_FORMAT_R16G16B16A16_SINT:
2716 case VK_FORMAT_R16G16B16A16_UINT:
2717 case VK_FORMAT_R16G16B16A16_SFLOAT:
2718 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
2719 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
2720 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
2721 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
2722 case VK_FORMAT_A2B10G10R10_UINT_PACK32:
2723 case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
2724 case VK_FORMAT_A2R10G10B10_UINT_PACK32:
2725 case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
2726 case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
2727 case VK_FORMAT_D16_UNORM:
2728 return false;
2729 default:
2730 UNSUPPORTED("Format: %d", int(format));
2731 }
2732
2733 return false;
2734 }
2735
has16bitTextureComponents() const2736 bool Format::has16bitTextureComponents() const
2737 {
2738 switch(format)
2739 {
2740 case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
2741 case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
2742 case VK_FORMAT_R5G6B5_UNORM_PACK16:
2743 case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
2744 case VK_FORMAT_A4R4G4B4_UNORM_PACK16:
2745 case VK_FORMAT_A4B4G4R4_UNORM_PACK16:
2746 case VK_FORMAT_B5G6R5_UNORM_PACK16:
2747 case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
2748 case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
2749 case VK_FORMAT_R8_UNORM:
2750 case VK_FORMAT_R8_SNORM:
2751 case VK_FORMAT_R8_UINT:
2752 case VK_FORMAT_R8_SINT:
2753 case VK_FORMAT_R8_SRGB:
2754 case VK_FORMAT_R8G8_UNORM:
2755 case VK_FORMAT_R8G8_SNORM:
2756 case VK_FORMAT_R8G8_UINT:
2757 case VK_FORMAT_R8G8_SINT:
2758 case VK_FORMAT_R8G8_SRGB:
2759 case VK_FORMAT_R8G8B8A8_UNORM:
2760 case VK_FORMAT_R8G8B8A8_SNORM:
2761 case VK_FORMAT_R8G8B8A8_UINT:
2762 case VK_FORMAT_R8G8B8A8_SINT:
2763 case VK_FORMAT_R8G8B8A8_SRGB:
2764 case VK_FORMAT_B8G8R8A8_UNORM:
2765 case VK_FORMAT_B8G8R8A8_SNORM:
2766 case VK_FORMAT_B8G8R8A8_UINT:
2767 case VK_FORMAT_B8G8R8A8_SINT:
2768 case VK_FORMAT_B8G8R8A8_SRGB:
2769 case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
2770 case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
2771 case VK_FORMAT_A8B8G8R8_UINT_PACK32:
2772 case VK_FORMAT_A8B8G8R8_SINT_PACK32:
2773 case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
2774 case VK_FORMAT_R32_UINT:
2775 case VK_FORMAT_R32_SINT:
2776 case VK_FORMAT_R32_SFLOAT:
2777 case VK_FORMAT_R32G32_UINT:
2778 case VK_FORMAT_R32G32_SINT:
2779 case VK_FORMAT_R32G32_SFLOAT:
2780 case VK_FORMAT_R32G32B32A32_UINT:
2781 case VK_FORMAT_R32G32B32A32_SINT:
2782 case VK_FORMAT_R32G32B32A32_SFLOAT:
2783 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
2784 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
2785 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
2786 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
2787 case VK_FORMAT_A2B10G10R10_UINT_PACK32:
2788 case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
2789 case VK_FORMAT_A2R10G10B10_UINT_PACK32:
2790 case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
2791 case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
2792 case VK_FORMAT_S8_UINT:
2793 return false;
2794 case VK_FORMAT_R16_UNORM:
2795 case VK_FORMAT_R16_SNORM:
2796 case VK_FORMAT_R16_UINT:
2797 case VK_FORMAT_R16_SINT:
2798 case VK_FORMAT_R16_SFLOAT:
2799 case VK_FORMAT_R16G16_UNORM:
2800 case VK_FORMAT_R16G16_SNORM:
2801 case VK_FORMAT_R16G16_UINT:
2802 case VK_FORMAT_R16G16_SINT:
2803 case VK_FORMAT_R16G16_SFLOAT:
2804 case VK_FORMAT_R16G16B16A16_UNORM:
2805 case VK_FORMAT_R16G16B16A16_SNORM:
2806 case VK_FORMAT_R16G16B16A16_UINT:
2807 case VK_FORMAT_R16G16B16A16_SINT:
2808 case VK_FORMAT_R16G16B16A16_SFLOAT:
2809 case VK_FORMAT_D16_UNORM:
2810 return true;
2811 default:
2812 UNSUPPORTED("Format: %d", int(format));
2813 }
2814
2815 return false;
2816 }
2817
has32bitIntegerTextureComponents() const2818 bool Format::has32bitIntegerTextureComponents() const
2819 {
2820 switch(format)
2821 {
2822 case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
2823 case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
2824 case VK_FORMAT_R5G6B5_UNORM_PACK16:
2825 case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
2826 case VK_FORMAT_A4B4G4R4_UNORM_PACK16:
2827 case VK_FORMAT_A4R4G4B4_UNORM_PACK16:
2828 case VK_FORMAT_B5G6R5_UNORM_PACK16:
2829 case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
2830 case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
2831 case VK_FORMAT_R8_UNORM:
2832 case VK_FORMAT_R8_SNORM:
2833 case VK_FORMAT_R8_UINT:
2834 case VK_FORMAT_R8_SINT:
2835 case VK_FORMAT_R8_SRGB:
2836 case VK_FORMAT_R8G8_UNORM:
2837 case VK_FORMAT_R8G8_SNORM:
2838 case VK_FORMAT_R8G8_UINT:
2839 case VK_FORMAT_R8G8_SINT:
2840 case VK_FORMAT_R8G8_SRGB:
2841 case VK_FORMAT_R8G8B8A8_UNORM:
2842 case VK_FORMAT_R8G8B8A8_SNORM:
2843 case VK_FORMAT_R8G8B8A8_UINT:
2844 case VK_FORMAT_R8G8B8A8_SINT:
2845 case VK_FORMAT_R8G8B8A8_SRGB:
2846 case VK_FORMAT_B8G8R8A8_UNORM:
2847 case VK_FORMAT_B8G8R8A8_SNORM:
2848 case VK_FORMAT_B8G8R8A8_UINT:
2849 case VK_FORMAT_B8G8R8A8_SINT:
2850 case VK_FORMAT_B8G8R8A8_SRGB:
2851 case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
2852 case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
2853 case VK_FORMAT_A8B8G8R8_UINT_PACK32:
2854 case VK_FORMAT_A8B8G8R8_SINT_PACK32:
2855 case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
2856 case VK_FORMAT_R16_UNORM:
2857 case VK_FORMAT_R16_SNORM:
2858 case VK_FORMAT_R16_UINT:
2859 case VK_FORMAT_R16_SINT:
2860 case VK_FORMAT_R16_SFLOAT:
2861 case VK_FORMAT_R16G16_UNORM:
2862 case VK_FORMAT_R16G16_SNORM:
2863 case VK_FORMAT_R16G16_UINT:
2864 case VK_FORMAT_R16G16_SINT:
2865 case VK_FORMAT_R16G16_SFLOAT:
2866 case VK_FORMAT_R16G16B16A16_UNORM:
2867 case VK_FORMAT_R16G16B16A16_SNORM:
2868 case VK_FORMAT_R16G16B16A16_UINT:
2869 case VK_FORMAT_R16G16B16A16_SINT:
2870 case VK_FORMAT_R16G16B16A16_SFLOAT:
2871 case VK_FORMAT_R32_SFLOAT:
2872 case VK_FORMAT_R32G32_SFLOAT:
2873 case VK_FORMAT_R32G32B32A32_SFLOAT:
2874 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
2875 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
2876 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
2877 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
2878 case VK_FORMAT_A2B10G10R10_UINT_PACK32:
2879 case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
2880 case VK_FORMAT_A2R10G10B10_UINT_PACK32:
2881 case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
2882 case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
2883 case VK_FORMAT_D16_UNORM:
2884 case VK_FORMAT_S8_UINT:
2885 return false;
2886 case VK_FORMAT_R32_SINT:
2887 case VK_FORMAT_R32_UINT:
2888 case VK_FORMAT_R32G32_SINT:
2889 case VK_FORMAT_R32G32_UINT:
2890 case VK_FORMAT_R32G32B32A32_SINT:
2891 case VK_FORMAT_R32G32B32A32_UINT:
2892 return true;
2893 default:
2894 UNSUPPORTED("Format: %d", int(format));
2895 }
2896
2897 return false;
2898 }
2899
isRGBComponent(int component) const2900 bool Format::isRGBComponent(int component) const
2901 {
2902 switch(format)
2903 {
2904 case VK_FORMAT_R8_UNORM:
2905 case VK_FORMAT_R8_SNORM:
2906 case VK_FORMAT_R8_UINT:
2907 case VK_FORMAT_R8_SINT:
2908 case VK_FORMAT_R8_SRGB:
2909 case VK_FORMAT_R16_UNORM:
2910 case VK_FORMAT_R16_SNORM:
2911 case VK_FORMAT_R16_UINT:
2912 case VK_FORMAT_R16_SINT:
2913 case VK_FORMAT_R16_SFLOAT:
2914 case VK_FORMAT_R32_UINT:
2915 case VK_FORMAT_R32_SINT:
2916 case VK_FORMAT_R32_SFLOAT:
2917 return component < 1;
2918 case VK_FORMAT_R8G8_UNORM:
2919 case VK_FORMAT_R8G8_SNORM:
2920 case VK_FORMAT_R8G8_UINT:
2921 case VK_FORMAT_R8G8_SINT:
2922 case VK_FORMAT_R8G8_SRGB:
2923 case VK_FORMAT_R16G16_UNORM:
2924 case VK_FORMAT_R16G16_SNORM:
2925 case VK_FORMAT_R16G16_UINT:
2926 case VK_FORMAT_R16G16_SINT:
2927 case VK_FORMAT_R16G16_SFLOAT:
2928 case VK_FORMAT_R32G32_UINT:
2929 case VK_FORMAT_R32G32_SINT:
2930 case VK_FORMAT_R32G32_SFLOAT:
2931 return component < 2;
2932 case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
2933 case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
2934 case VK_FORMAT_R5G6B5_UNORM_PACK16:
2935 case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
2936 case VK_FORMAT_A4B4G4R4_UNORM_PACK16:
2937 case VK_FORMAT_A4R4G4B4_UNORM_PACK16:
2938 case VK_FORMAT_B5G6R5_UNORM_PACK16:
2939 case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
2940 case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
2941 case VK_FORMAT_R8G8B8A8_UNORM:
2942 case VK_FORMAT_R8G8B8A8_SNORM:
2943 case VK_FORMAT_R8G8B8A8_UINT:
2944 case VK_FORMAT_R8G8B8A8_SINT:
2945 case VK_FORMAT_R8G8B8A8_SRGB:
2946 case VK_FORMAT_B8G8R8A8_UNORM:
2947 case VK_FORMAT_B8G8R8A8_SNORM:
2948 case VK_FORMAT_B8G8R8A8_UINT:
2949 case VK_FORMAT_B8G8R8A8_SINT:
2950 case VK_FORMAT_B8G8R8A8_SRGB:
2951 case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
2952 case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
2953 case VK_FORMAT_A8B8G8R8_UINT_PACK32:
2954 case VK_FORMAT_A8B8G8R8_SINT_PACK32:
2955 case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
2956 case VK_FORMAT_R16G16B16A16_UNORM:
2957 case VK_FORMAT_R16G16B16A16_SINT:
2958 case VK_FORMAT_R16G16B16A16_UINT:
2959 case VK_FORMAT_R16G16B16A16_SFLOAT:
2960 case VK_FORMAT_R32G32B32A32_SINT:
2961 case VK_FORMAT_R32G32B32A32_UINT:
2962 case VK_FORMAT_R32G32B32A32_SFLOAT:
2963 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
2964 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
2965 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
2966 case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
2967 case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
2968 return component < 3;
2969 case VK_FORMAT_D32_SFLOAT:
2970 case VK_FORMAT_D16_UNORM:
2971 case VK_FORMAT_S8_UINT:
2972 return false;
2973 default:
2974 UNSUPPORTED("Format: %d", int(format));
2975 }
2976
2977 return false;
2978 }
2979
pack(VkFormat format)2980 static constexpr uint8_t pack(VkFormat format)
2981 {
2982 if(format > VK_FORMAT_A4B4G4R4_UNORM_PACK16)
2983 {
2984 return 0;
2985 }
2986
2987 // 0 - 184 direct mapping
2988 if(format >= 0 && format <= VK_FORMAT_ASTC_12x12_SRGB_BLOCK)
2989 {
2990 return uint8_t(format);
2991 }
2992
2993 // 10001560xx -> 185 - 218
2994 if(format >= VK_FORMAT_G8B8G8R8_422_UNORM && format <= VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM)
2995 {
2996 return uint8_t(format - VK_FORMAT_G8B8G8R8_422_UNORM + 185);
2997 }
2998
2999 // 100005400x -> 219 - 226
3000 if(format >= VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG && format <= VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG)
3001 {
3002 return uint8_t(format - VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG + 219);
3003 }
3004
3005 // 10000660xx -> 227 - 240
3006 if(format >= VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK && format <= VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK)
3007 {
3008 return uint8_t(format - VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK + 227);
3009 }
3010
3011 // 100034000x -> 241 - 242
3012 if(format >= VK_FORMAT_A4R4G4B4_UNORM_PACK16 && format <= VK_FORMAT_A4B4G4R4_UNORM_PACK16)
3013 {
3014 return uint8_t(format - VK_FORMAT_A4R4G4B4_UNORM_PACK16 + 241);
3015 }
3016
3017 return 0;
3018 }
3019
3020 static_assert(pack(VK_FORMAT_UNDEFINED) == 0, "Incorrect VkFormat packed value");
3021 static_assert(pack(VK_FORMAT_ASTC_12x12_SRGB_BLOCK) == 184, "Incorrect VkFormat packed value");
3022 static_assert(pack(VK_FORMAT_G8B8G8R8_422_UNORM) == 185, "Incorrect VkFormat packed value");
3023 static_assert(pack(VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM) == 218, "Incorrect VkFormat packed value");
3024 static_assert(pack(VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG) == 219, "Incorrect VkFormat packed value");
3025 static_assert(pack(VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG) == 226, "Incorrect VkFormat packed value");
3026 static_assert(pack(VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK) == 227, "Incorrect VkFormat packed value");
3027 static_assert(pack(VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK) == 240, "Incorrect VkFormat packed value");
3028 static_assert(pack(VK_FORMAT_A4R4G4B4_UNORM_PACK16) == 241, "Incorrect VkFormat packed value");
3029 static_assert(pack(VK_FORMAT_A4B4G4R4_UNORM_PACK16) == 242, "Incorrect VkFormat packed value");
3030
unpack(uint8_t format)3031 static constexpr VkFormat unpack(uint8_t format)
3032 {
3033 // 0 - 184 direct mapping
3034 if(format >= 0 && format <= 184)
3035 {
3036 return static_cast<VkFormat>(format);
3037 }
3038
3039 // 185 - 218 -> 10001560xx
3040 if(format >= 185 && format <= 218)
3041 {
3042 return static_cast<VkFormat>(VK_FORMAT_G8B8G8R8_422_UNORM + (format - 185));
3043 }
3044
3045 // 219 - 226 -> 100005400x
3046 if(format >= 219 && format <= 226)
3047 {
3048 return static_cast<VkFormat>(VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG + (format - 219));
3049 }
3050
3051 // 227 - 240 -> 10000660xx
3052 if(format >= 227 && format <= 240)
3053 {
3054 return static_cast<VkFormat>(VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK + (format - 227));
3055 }
3056
3057 // 241 - 242 -> 100034000x
3058 if(format >= 241 && format <= 242)
3059 {
3060 return static_cast<VkFormat>(VK_FORMAT_A4R4G4B4_UNORM_PACK16 + (format - 241));
3061 }
3062
3063 return VK_FORMAT_UNDEFINED;
3064 }
3065
3066 static_assert(unpack(0) == VK_FORMAT_UNDEFINED, "Incorrect VkFormat unpacked value");
3067 static_assert(unpack(184) == VK_FORMAT_ASTC_12x12_SRGB_BLOCK, "Incorrect VkFormat unpacked value");
3068 static_assert(unpack(185) == VK_FORMAT_G8B8G8R8_422_UNORM, "Incorrect VkFormat unpacked value");
3069 static_assert(unpack(218) == VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, "Incorrect VkFormat unpacked value");
3070 static_assert(unpack(219) == VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG, "Incorrect VkFormat unpacked value");
3071 static_assert(unpack(226) == VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG, "Incorrect VkFormat unpacked value");
3072 static_assert(unpack(227) == VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK, "Incorrect VkFormat unpacked value");
3073 static_assert(unpack(240) == VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK, "Incorrect VkFormat unpacked value");
3074 static_assert(unpack(241) == VK_FORMAT_A4R4G4B4_UNORM_PACK16, "Incorrect VkFormat unpacked value");
3075 static_assert(unpack(242) == VK_FORMAT_A4B4G4R4_UNORM_PACK16, "Incorrect VkFormat unpacked value");
3076 static_assert(unpack(243) == VK_FORMAT_UNDEFINED, "Incorrect VkFormat unpacked value");
3077
mapTo8bit(VkFormat format)3078 uint8_t Format::mapTo8bit(VkFormat format)
3079 {
3080 ASSERT(format <= VK_FORMAT_A4B4G4R4_UNORM_PACK16);
3081 uint8_t packed = pack(format);
3082 ASSERT_MSG(packed > 0, "Update VkFormat to uint8_t mapping");
3083 return packed;
3084 }
3085
mapFrom8bit(uint8_t format)3086 VkFormat Format::mapFrom8bit(uint8_t format)
3087 {
3088 ASSERT(format <= 242);
3089 VkFormat unpacked = unpack(format);
3090 ASSERT_MSG(unpacked != VK_FORMAT_UNDEFINED, "Update uint8_t to VkFormat mapping");
3091 return unpacked;
3092 }
3093
3094 } // namespace vk
3095