1 // Copyright 2018 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 "VkPhysicalDevice.hpp"
16
17 #include "VkConfig.hpp"
18 #include "VkStringify.hpp"
19 #include "Pipeline/SpirvShader.hpp" // sw::SIMD::Width
20 #include "Reactor/Reactor.hpp"
21
22 #include <cstring>
23 #include <limits>
24
25 #ifdef __ANDROID__
26 # include <android/hardware_buffer.h>
27 #endif
28
29 namespace vk {
30
PhysicalDevice(const void *,void * mem)31 PhysicalDevice::PhysicalDevice(const void *, void *mem)
32 {
33 }
34
getFeatures() const35 const VkPhysicalDeviceFeatures &PhysicalDevice::getFeatures() const
36 {
37 static const VkPhysicalDeviceFeatures features{
38 VK_TRUE, // robustBufferAccess
39 VK_TRUE, // fullDrawIndexUint32
40 VK_TRUE, // imageCubeArray
41 VK_TRUE, // independentBlend
42 VK_FALSE, // geometryShader
43 VK_FALSE, // tessellationShader
44 VK_TRUE, // sampleRateShading
45 VK_FALSE, // dualSrcBlend
46 VK_FALSE, // logicOp
47 VK_TRUE, // multiDrawIndirect
48 VK_TRUE, // drawIndirectFirstInstance
49 VK_TRUE, // depthClamp
50 VK_TRUE, // depthBiasClamp
51 VK_TRUE, // fillModeNonSolid
52 VK_TRUE, // depthBounds
53 VK_FALSE, // wideLines
54 VK_TRUE, // largePoints
55 VK_FALSE, // alphaToOne
56 VK_FALSE, // multiViewport
57 VK_TRUE, // samplerAnisotropy
58 VK_TRUE, // textureCompressionETC2
59 #ifdef SWIFTSHADER_ENABLE_ASTC
60 VK_TRUE, // textureCompressionASTC_LDR
61 #else
62 VK_FALSE, // textureCompressionASTC_LDR
63 #endif
64 VK_TRUE, // textureCompressionBC
65 VK_TRUE, // occlusionQueryPrecise
66 VK_FALSE, // pipelineStatisticsQuery
67 VK_TRUE, // vertexPipelineStoresAndAtomics
68 VK_TRUE, // fragmentStoresAndAtomics
69 VK_FALSE, // shaderTessellationAndGeometryPointSize
70 VK_FALSE, // shaderImageGatherExtended
71 VK_TRUE, // shaderStorageImageExtendedFormats
72 VK_TRUE, // shaderStorageImageMultisample
73 VK_FALSE, // shaderStorageImageReadWithoutFormat
74 VK_TRUE, // shaderStorageImageWriteWithoutFormat
75 VK_TRUE, // shaderUniformBufferArrayDynamicIndexing
76 VK_TRUE, // shaderSampledImageArrayDynamicIndexing
77 VK_TRUE, // shaderStorageBufferArrayDynamicIndexing
78 VK_TRUE, // shaderStorageImageArrayDynamicIndexing
79 VK_TRUE, // shaderClipDistance
80 VK_TRUE, // shaderCullDistance
81 VK_FALSE, // shaderFloat64
82 VK_FALSE, // shaderInt64
83 VK_FALSE, // shaderInt16
84 VK_FALSE, // shaderResourceResidency
85 VK_FALSE, // shaderResourceMinLod
86 VK_FALSE, // sparseBinding
87 VK_FALSE, // sparseResidencyBuffer
88 VK_FALSE, // sparseResidencyImage2D
89 VK_FALSE, // sparseResidencyImage3D
90 VK_FALSE, // sparseResidency2Samples
91 VK_FALSE, // sparseResidency4Samples
92 VK_FALSE, // sparseResidency8Samples
93 VK_FALSE, // sparseResidency16Samples
94 VK_FALSE, // sparseResidencyAliased
95 VK_TRUE, // variableMultisampleRate
96 VK_FALSE, // inheritedQueries
97 };
98
99 return features;
100 }
101
102 template<typename T>
getPhysicalDeviceSamplerYcbcrConversionFeatures(T * features)103 static void getPhysicalDeviceSamplerYcbcrConversionFeatures(T *features)
104 {
105 features->samplerYcbcrConversion = VK_TRUE;
106 }
107
108 template<typename T>
getPhysicalDevice16BitStorageFeatures(T * features)109 static void getPhysicalDevice16BitStorageFeatures(T *features)
110 {
111 features->storageBuffer16BitAccess = VK_FALSE;
112 features->storageInputOutput16 = VK_FALSE;
113 features->storagePushConstant16 = VK_FALSE;
114 features->uniformAndStorageBuffer16BitAccess = VK_FALSE;
115 }
116
117 template<typename T>
getPhysicalDeviceVariablePointersFeatures(T * features)118 static void getPhysicalDeviceVariablePointersFeatures(T *features)
119 {
120 features->variablePointersStorageBuffer = VK_FALSE;
121 features->variablePointers = VK_FALSE;
122 }
123
124 template<typename T>
getPhysicalDevice8BitStorageFeaturesKHR(T * features)125 static void getPhysicalDevice8BitStorageFeaturesKHR(T *features)
126 {
127 features->storageBuffer8BitAccess = VK_FALSE;
128 features->uniformAndStorageBuffer8BitAccess = VK_FALSE;
129 features->storagePushConstant8 = VK_FALSE;
130 }
131
132 template<typename T>
getPhysicalDeviceMultiviewFeatures(T * features)133 static void getPhysicalDeviceMultiviewFeatures(T *features)
134 {
135 features->multiview = VK_TRUE;
136 features->multiviewGeometryShader = VK_FALSE;
137 features->multiviewTessellationShader = VK_FALSE;
138 }
139
140 template<typename T>
getPhysicalDeviceProtectedMemoryFeatures(T * features)141 static void getPhysicalDeviceProtectedMemoryFeatures(T *features)
142 {
143 features->protectedMemory = VK_FALSE;
144 }
145
146 template<typename T>
getPhysicalDeviceShaderDrawParameterFeatures(T * features)147 static void getPhysicalDeviceShaderDrawParameterFeatures(T *features)
148 {
149 features->shaderDrawParameters = VK_FALSE;
150 }
151
152 template<typename T>
getPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR(T * features)153 static void getPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR(T *features)
154 {
155 features->separateDepthStencilLayouts = VK_TRUE;
156 }
157
158 template<typename T>
getPhysicalDeviceLineRasterizationFeaturesEXT(T * features)159 static void getPhysicalDeviceLineRasterizationFeaturesEXT(T *features)
160 {
161 features->rectangularLines = VK_TRUE;
162 features->bresenhamLines = VK_TRUE;
163 features->smoothLines = VK_FALSE;
164 features->stippledRectangularLines = VK_FALSE;
165 features->stippledBresenhamLines = VK_FALSE;
166 features->stippledSmoothLines = VK_FALSE;
167 }
168
169 template<typename T>
getPhysicalDeviceProvokingVertexFeaturesEXT(T * features)170 static void getPhysicalDeviceProvokingVertexFeaturesEXT(T *features)
171 {
172 features->provokingVertexLast = VK_TRUE;
173 features->transformFeedbackPreservesProvokingVertex = VK_FALSE;
174 }
175
176 template<typename T>
getPhysicalDeviceHostQueryResetFeatures(T * features)177 static void getPhysicalDeviceHostQueryResetFeatures(T *features)
178 {
179 features->hostQueryReset = VK_TRUE;
180 }
181
182 template<typename T>
getPhysicalDevicePipelineCreationCacheControlFeatures(T * features)183 static void getPhysicalDevicePipelineCreationCacheControlFeatures(T *features)
184 {
185 features->pipelineCreationCacheControl = VK_TRUE;
186 }
187
188 template<typename T>
getPhysicalDeviceImageRobustnessFeaturesEXT(T * features)189 static void getPhysicalDeviceImageRobustnessFeaturesEXT(T *features)
190 {
191 features->robustImageAccess = VK_TRUE;
192 }
193
194 template<typename T>
getPhysicalDeviceShaderDrawParametersFeatures(T * features)195 static void getPhysicalDeviceShaderDrawParametersFeatures(T *features)
196 {
197 features->shaderDrawParameters = VK_FALSE;
198 }
199
200 template<typename T>
getPhysicalDeviceVulkan11Features(T * features)201 static void getPhysicalDeviceVulkan11Features(T *features)
202 {
203 getPhysicalDevice16BitStorageFeatures(features);
204 getPhysicalDeviceMultiviewFeatures(features);
205 getPhysicalDeviceVariablePointersFeatures(features);
206 getPhysicalDeviceProtectedMemoryFeatures(features);
207 getPhysicalDeviceSamplerYcbcrConversionFeatures(features);
208 getPhysicalDeviceShaderDrawParametersFeatures(features);
209 }
210
211 template<typename T>
getPhysicalDeviceImagelessFramebufferFeatures(T * features)212 static void getPhysicalDeviceImagelessFramebufferFeatures(T *features)
213 {
214 features->imagelessFramebuffer = VK_TRUE;
215 }
216
217 template<typename T>
getPhysicalDeviceShaderSubgroupExtendedTypesFeatures(T * features)218 static void getPhysicalDeviceShaderSubgroupExtendedTypesFeatures(T *features)
219 {
220 features->shaderSubgroupExtendedTypes = VK_TRUE;
221 }
222
223 template<typename T>
getPhysicalDeviceScalarBlockLayoutFeatures(T * features)224 static void getPhysicalDeviceScalarBlockLayoutFeatures(T *features)
225 {
226 features->scalarBlockLayout = VK_TRUE;
227 }
228
229 #ifdef SWIFTSHADER_DEVICE_MEMORY_REPORT
230 template<typename T>
getPhysicalDeviceDeviceMemoryReportFeaturesEXT(T * features)231 static void getPhysicalDeviceDeviceMemoryReportFeaturesEXT(T *features)
232 {
233 features->deviceMemoryReport = VK_TRUE;
234 }
235 #endif // SWIFTSHADER_DEVICE_MEMORY_REPORT
236
237 template<typename T>
getPhysicalDeviceUniformBufferStandardLayoutFeatures(T * features)238 static void getPhysicalDeviceUniformBufferStandardLayoutFeatures(T *features)
239 {
240 features->uniformBufferStandardLayout = VK_TRUE;
241 }
242
243 template<typename T>
getPhysicalDeviceDescriptorIndexingFeatures(T * features)244 static void getPhysicalDeviceDescriptorIndexingFeatures(T *features)
245 {
246 features->shaderInputAttachmentArrayDynamicIndexing = VK_FALSE;
247 features->shaderUniformTexelBufferArrayDynamicIndexing = VK_FALSE;
248 features->shaderStorageTexelBufferArrayDynamicIndexing = VK_FALSE;
249 features->shaderUniformBufferArrayNonUniformIndexing = VK_FALSE;
250 features->shaderSampledImageArrayNonUniformIndexing = VK_FALSE;
251 features->shaderStorageBufferArrayNonUniformIndexing = VK_FALSE;
252 features->shaderStorageImageArrayNonUniformIndexing = VK_FALSE;
253 features->shaderInputAttachmentArrayNonUniformIndexing = VK_FALSE;
254 features->shaderUniformTexelBufferArrayNonUniformIndexing = VK_FALSE;
255 features->shaderStorageTexelBufferArrayNonUniformIndexing = VK_FALSE;
256 features->descriptorBindingUniformBufferUpdateAfterBind = VK_FALSE;
257 features->descriptorBindingSampledImageUpdateAfterBind = VK_FALSE;
258 features->descriptorBindingStorageImageUpdateAfterBind = VK_FALSE;
259 features->descriptorBindingStorageBufferUpdateAfterBind = VK_FALSE;
260 features->descriptorBindingUniformTexelBufferUpdateAfterBind = VK_FALSE;
261 features->descriptorBindingStorageTexelBufferUpdateAfterBind = VK_FALSE;
262 features->descriptorBindingUpdateUnusedWhilePending = VK_FALSE;
263 features->descriptorBindingPartiallyBound = VK_FALSE;
264 features->descriptorBindingVariableDescriptorCount = VK_FALSE;
265 features->runtimeDescriptorArray = VK_FALSE;
266 }
267
268 template<typename T>
getPhysicalDeviceVulkanMemoryModelFeatures(T * features)269 static void getPhysicalDeviceVulkanMemoryModelFeatures(T *features)
270 {
271 features->vulkanMemoryModel = VK_FALSE;
272 features->vulkanMemoryModelDeviceScope = VK_FALSE;
273 features->vulkanMemoryModelAvailabilityVisibilityChains = VK_FALSE;
274 }
275
276 template<typename T>
getPhysicalDeviceTimelineSemaphoreFeatures(T * features)277 static void getPhysicalDeviceTimelineSemaphoreFeatures(T *features)
278 {
279 features->timelineSemaphore = VK_TRUE;
280 }
281
282 template<typename T>
getPhysicalDeviceShaderAtomicInt64Features(T * features)283 static void getPhysicalDeviceShaderAtomicInt64Features(T *features)
284 {
285 features->shaderBufferInt64Atomics = VK_FALSE;
286 features->shaderSharedInt64Atomics = VK_FALSE;
287 }
288
289 template<typename T>
getPhysicalDeviceShaderFloat16Int8Features(T * features)290 static void getPhysicalDeviceShaderFloat16Int8Features(T *features)
291 {
292 features->shaderFloat16 = VK_FALSE;
293 features->shaderInt8 = VK_FALSE;
294 }
295
296 template<typename T>
getPhysicalDeviceBufferDeviceAddressFeatures(T * features)297 static void getPhysicalDeviceBufferDeviceAddressFeatures(T *features)
298 {
299 features->bufferDeviceAddress = VK_FALSE;
300 features->bufferDeviceAddressCaptureReplay = VK_FALSE;
301 features->bufferDeviceAddressMultiDevice = VK_FALSE;
302 }
303
304 template<typename T>
getPhysicalDeviceVulkan12Features(T * features)305 static void getPhysicalDeviceVulkan12Features(T *features)
306 {
307 features->samplerMirrorClampToEdge = VK_FALSE;
308 features->drawIndirectCount = VK_FALSE;
309 getPhysicalDevice8BitStorageFeaturesKHR(features);
310 getPhysicalDeviceShaderAtomicInt64Features(features);
311 getPhysicalDeviceShaderFloat16Int8Features(features);
312 features->descriptorIndexing = VK_FALSE;
313 getPhysicalDeviceDescriptorIndexingFeatures(features);
314 features->samplerFilterMinmax = VK_FALSE;
315 getPhysicalDeviceScalarBlockLayoutFeatures(features);
316 getPhysicalDeviceImagelessFramebufferFeatures(features);
317 getPhysicalDeviceUniformBufferStandardLayoutFeatures(features);
318 getPhysicalDeviceShaderSubgroupExtendedTypesFeatures(features);
319 getPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR(features);
320 getPhysicalDeviceHostQueryResetFeatures(features);
321 getPhysicalDeviceTimelineSemaphoreFeatures(features);
322 getPhysicalDeviceBufferDeviceAddressFeatures(features);
323 getPhysicalDeviceVulkanMemoryModelFeatures(features);
324 features->shaderOutputViewportIndex = VK_FALSE;
325 features->shaderOutputLayer = VK_FALSE;
326 features->subgroupBroadcastDynamicId = VK_TRUE;
327 }
328
329 template<typename T>
getPhysicalDeviceDepthClipEnableFeaturesExt(T * features)330 static void getPhysicalDeviceDepthClipEnableFeaturesExt(T *features)
331 {
332 features->depthClipEnable = VK_TRUE;
333 }
334
getPhysicalDeviceCustomBorderColorFeaturesExt(VkPhysicalDeviceCustomBorderColorFeaturesEXT * features)335 static void getPhysicalDeviceCustomBorderColorFeaturesExt(VkPhysicalDeviceCustomBorderColorFeaturesEXT *features)
336 {
337 features->customBorderColors = VK_TRUE;
338 features->customBorderColorWithoutFormat = VK_TRUE;
339 }
340
getPhysicalDeviceBlendOperationAdvancedFeaturesExt(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT * features)341 static void getPhysicalDeviceBlendOperationAdvancedFeaturesExt(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *features)
342 {
343 features->advancedBlendCoherentOperations = VK_FALSE;
344 }
345
getPhysicalDevice4444FormatsFeaturesExt(VkPhysicalDevice4444FormatsFeaturesEXT * features)346 static void getPhysicalDevice4444FormatsFeaturesExt(VkPhysicalDevice4444FormatsFeaturesEXT *features)
347 {
348 features->formatA4R4G4B4 = VK_TRUE;
349 features->formatA4B4G4R4 = VK_TRUE;
350 }
351
getFeatures2(VkPhysicalDeviceFeatures2 * features) const352 void PhysicalDevice::getFeatures2(VkPhysicalDeviceFeatures2 *features) const
353 {
354 features->features = getFeatures();
355 VkBaseOutStructure *curExtension = reinterpret_cast<VkBaseOutStructure *>(features->pNext);
356 while(curExtension != nullptr)
357 {
358 // Need to switch on an integer since Provoking Vertex isn't a part of the Vulkan spec.
359 switch((int)curExtension->sType)
360 {
361 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
362 getPhysicalDeviceVulkan11Features(reinterpret_cast<VkPhysicalDeviceVulkan11Features *>(curExtension));
363 break;
364 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
365 getPhysicalDeviceVulkan12Features(reinterpret_cast<VkPhysicalDeviceVulkan12Features *>(curExtension));
366 break;
367 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
368 getPhysicalDeviceMultiviewFeatures(reinterpret_cast<VkPhysicalDeviceMultiviewFeatures *>(curExtension));
369 break;
370 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
371 getPhysicalDeviceVariablePointersFeatures(reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures *>(curExtension));
372 break;
373 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
374 getPhysicalDevice16BitStorageFeatures(reinterpret_cast<VkPhysicalDevice16BitStorageFeatures *>(curExtension));
375 break;
376 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
377 getPhysicalDeviceSamplerYcbcrConversionFeatures(reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures *>(curExtension));
378 break;
379 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
380 getPhysicalDeviceProtectedMemoryFeatures(reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures *>(curExtension));
381 break;
382 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
383 getPhysicalDeviceShaderDrawParameterFeatures(reinterpret_cast<VkPhysicalDeviceShaderDrawParameterFeatures *>(curExtension));
384 break;
385 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
386 getPhysicalDeviceHostQueryResetFeatures(reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures *>(curExtension));
387 break;
388 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT:
389 getPhysicalDevicePipelineCreationCacheControlFeatures(reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT *>(curExtension));
390 break;
391 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT:
392 getPhysicalDeviceImageRobustnessFeaturesEXT(reinterpret_cast<VkPhysicalDeviceImageRobustnessFeaturesEXT *>(curExtension));
393 break;
394 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
395 getPhysicalDeviceLineRasterizationFeaturesEXT(reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT *>(curExtension));
396 break;
397 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
398 getPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR(reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *>(curExtension));
399 break;
400 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR:
401 getPhysicalDevice8BitStorageFeaturesKHR(reinterpret_cast<VkPhysicalDevice8BitStorageFeaturesKHR *>(curExtension));
402 break;
403 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
404 getPhysicalDeviceProvokingVertexFeaturesEXT(reinterpret_cast<VkPhysicalDeviceProvokingVertexFeaturesEXT *>(curExtension));
405 break;
406 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
407 getPhysicalDeviceImagelessFramebufferFeatures(reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures *>(curExtension));
408 break;
409 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR:
410 getPhysicalDeviceShaderSubgroupExtendedTypesFeatures(reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *>(curExtension));
411 break;
412 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
413 getPhysicalDeviceScalarBlockLayoutFeatures(reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures *>(curExtension));
414 break;
415 #ifdef SWIFTSHADER_DEVICE_MEMORY_REPORT
416 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
417 getPhysicalDeviceDeviceMemoryReportFeaturesEXT(reinterpret_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *>(curExtension));
418 break;
419 #endif // SWIFTSHADER_DEVICE_MEMORY_REPORT
420 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
421 getPhysicalDeviceUniformBufferStandardLayoutFeatures(reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures *>(curExtension));
422 break;
423 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
424 getPhysicalDeviceVulkanMemoryModelFeatures(reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures *>(curExtension));
425 break;
426 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
427 getPhysicalDeviceTimelineSemaphoreFeatures(reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures *>(curExtension));
428 break;
429 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
430 getPhysicalDeviceShaderAtomicInt64Features(reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features *>(curExtension));
431 break;
432 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
433 getPhysicalDeviceShaderFloat16Int8Features(reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features *>(curExtension));
434 break;
435 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
436 getPhysicalDeviceBufferDeviceAddressFeatures(reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures *>(curExtension));
437 break;
438 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
439 getPhysicalDeviceDescriptorIndexingFeatures(reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures *>(curExtension));
440 break;
441 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
442 getPhysicalDeviceDepthClipEnableFeaturesExt(reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT *>(curExtension));
443 break;
444 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
445 getPhysicalDeviceCustomBorderColorFeaturesExt(reinterpret_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT *>(curExtension));
446 break;
447 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
448 getPhysicalDeviceBlendOperationAdvancedFeaturesExt(reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *>(curExtension));
449 break;
450 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
451 getPhysicalDevice4444FormatsFeaturesExt(reinterpret_cast<struct VkPhysicalDevice4444FormatsFeaturesEXT *>(curExtension));
452 // Unsupported extensions, but used by dEQP
453 // TODO(b/176893525): This may not be legal.
454 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
455 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
456 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
457 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
458 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
459 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR:
460 break;
461 default:
462 UNSUPPORTED("curExtension->sType: %s", vk::Stringify(curExtension->sType).c_str());
463 break;
464 }
465 curExtension = reinterpret_cast<VkBaseOutStructure *>(curExtension->pNext);
466 }
467 }
468
getSampleCounts()469 VkSampleCountFlags PhysicalDevice::getSampleCounts()
470 {
471 return VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT;
472 }
473
getLimits()474 const VkPhysicalDeviceLimits &PhysicalDevice::getLimits()
475 {
476 VkSampleCountFlags sampleCounts = getSampleCounts();
477
478 static const VkPhysicalDeviceLimits limits = {
479 1 << (vk::MAX_IMAGE_LEVELS_1D - 1), // maxImageDimension1D
480 1 << (vk::MAX_IMAGE_LEVELS_2D - 1), // maxImageDimension2D
481 1 << (vk::MAX_IMAGE_LEVELS_3D - 1), // maxImageDimension3D
482 1 << (vk::MAX_IMAGE_LEVELS_CUBE - 1), // maxImageDimensionCube
483 vk::MAX_IMAGE_ARRAY_LAYERS, // maxImageArrayLayers
484 65536, // maxTexelBufferElements
485 65536, // maxUniformBufferRange
486 vk::MAX_MEMORY_ALLOCATION_SIZE, // maxStorageBufferRange
487 vk::MAX_PUSH_CONSTANT_SIZE, // maxPushConstantsSize
488 4096, // maxMemoryAllocationCount
489 vk::MAX_SAMPLER_ALLOCATION_COUNT, // maxSamplerAllocationCount
490 131072, // bufferImageGranularity
491 0, // sparseAddressSpaceSize (unsupported)
492 MAX_BOUND_DESCRIPTOR_SETS, // maxBoundDescriptorSets
493 16, // maxPerStageDescriptorSamplers
494 14, // maxPerStageDescriptorUniformBuffers
495 16, // maxPerStageDescriptorStorageBuffers
496 16, // maxPerStageDescriptorSampledImages
497 4, // maxPerStageDescriptorStorageImages
498 sw::MAX_COLOR_BUFFERS, // maxPerStageDescriptorInputAttachments
499 128, // maxPerStageResources
500 96, // maxDescriptorSetSamplers
501 72, // maxDescriptorSetUniformBuffers
502 MAX_DESCRIPTOR_SET_UNIFORM_BUFFERS_DYNAMIC, // maxDescriptorSetUniformBuffersDynamic
503 24, // maxDescriptorSetStorageBuffers
504 MAX_DESCRIPTOR_SET_STORAGE_BUFFERS_DYNAMIC, // maxDescriptorSetStorageBuffersDynamic
505 96, // maxDescriptorSetSampledImages
506 24, // maxDescriptorSetStorageImages
507 sw::MAX_COLOR_BUFFERS, // maxDescriptorSetInputAttachments
508 16, // maxVertexInputAttributes
509 vk::MAX_VERTEX_INPUT_BINDINGS, // maxVertexInputBindings
510 2047, // maxVertexInputAttributeOffset
511 2048, // maxVertexInputBindingStride
512 sw::MAX_INTERFACE_COMPONENTS, // maxVertexOutputComponents
513 0, // maxTessellationGenerationLevel (unsupported)
514 0, // maxTessellationPatchSize (unsupported)
515 0, // maxTessellationControlPerVertexInputComponents (unsupported)
516 0, // maxTessellationControlPerVertexOutputComponents (unsupported)
517 0, // maxTessellationControlPerPatchOutputComponents (unsupported)
518 0, // maxTessellationControlTotalOutputComponents (unsupported)
519 0, // maxTessellationEvaluationInputComponents (unsupported)
520 0, // maxTessellationEvaluationOutputComponents (unsupported)
521 0, // maxGeometryShaderInvocations (unsupported)
522 0, // maxGeometryInputComponents (unsupported)
523 0, // maxGeometryOutputComponents (unsupported)
524 0, // maxGeometryOutputVertices (unsupported)
525 0, // maxGeometryTotalOutputComponents (unsupported)
526 sw::MAX_INTERFACE_COMPONENTS, // maxFragmentInputComponents
527 sw::MAX_COLOR_BUFFERS, // maxFragmentOutputAttachments
528 1, // maxFragmentDualSrcAttachments
529 28, // maxFragmentCombinedOutputResources
530 32768, // maxComputeSharedMemorySize
531 { 65535, 65535, 65535 }, // maxComputeWorkGroupCount[3]
532 256, // maxComputeWorkGroupInvocations
533 { 256, 256, 64 }, // maxComputeWorkGroupSize[3]
534 vk::SUBPIXEL_PRECISION_BITS, // subPixelPrecisionBits
535 4, // subTexelPrecisionBits
536 4, // mipmapPrecisionBits
537 UINT32_MAX, // maxDrawIndexedIndexValue
538 UINT32_MAX, // maxDrawIndirectCount
539 vk::MAX_SAMPLER_LOD_BIAS, // maxSamplerLodBias
540 16, // maxSamplerAnisotropy
541 16, // maxViewports
542 { sw::MAX_VIEWPORT_DIM,
543 sw::MAX_VIEWPORT_DIM }, // maxViewportDimensions[2]
544 { -2 * sw::MAX_VIEWPORT_DIM,
545 2 * sw::MAX_VIEWPORT_DIM - 1 }, // viewportBoundsRange[2]
546 0, // viewportSubPixelBits
547 64, // minMemoryMapAlignment
548 vk::MIN_TEXEL_BUFFER_OFFSET_ALIGNMENT, // minTexelBufferOffsetAlignment
549 vk::MIN_UNIFORM_BUFFER_OFFSET_ALIGNMENT, // minUniformBufferOffsetAlignment
550 vk::MIN_STORAGE_BUFFER_OFFSET_ALIGNMENT, // minStorageBufferOffsetAlignment
551 sw::MIN_TEXEL_OFFSET, // minTexelOffset
552 sw::MAX_TEXEL_OFFSET, // maxTexelOffset
553 sw::MIN_TEXEL_OFFSET, // minTexelGatherOffset
554 sw::MAX_TEXEL_OFFSET, // maxTexelGatherOffset
555 -0.5, // minInterpolationOffset
556 0.5, // maxInterpolationOffset
557 4, // subPixelInterpolationOffsetBits
558 sw::MAX_FRAMEBUFFER_DIM, // maxFramebufferWidth
559 sw::MAX_FRAMEBUFFER_DIM, // maxFramebufferHeight
560 256, // maxFramebufferLayers
561 sampleCounts, // framebufferColorSampleCounts
562 sampleCounts, // framebufferDepthSampleCounts
563 sampleCounts, // framebufferStencilSampleCounts
564 sampleCounts, // framebufferNoAttachmentsSampleCounts
565 sw::MAX_COLOR_BUFFERS, // maxColorAttachments
566 sampleCounts, // sampledImageColorSampleCounts
567 sampleCounts, // sampledImageIntegerSampleCounts
568 sampleCounts, // sampledImageDepthSampleCounts
569 sampleCounts, // sampledImageStencilSampleCounts
570 sampleCounts, // storageImageSampleCounts
571 1, // maxSampleMaskWords
572 VK_TRUE, // timestampComputeAndGraphics
573 1, // timestampPeriod
574 sw::MAX_CLIP_DISTANCES, // maxClipDistances
575 sw::MAX_CULL_DISTANCES, // maxCullDistances
576 sw::MAX_CLIP_DISTANCES + sw::MAX_CULL_DISTANCES, // maxCombinedClipAndCullDistances
577 2, // discreteQueuePriorities
578 { 1.0, vk::MAX_POINT_SIZE }, // pointSizeRange[2]
579 { 1.0, 1.0 }, // lineWidthRange[2] (unsupported)
580 0.0, // pointSizeGranularity (unsupported)
581 0.0, // lineWidthGranularity (unsupported)
582 VK_TRUE, // strictLines
583 VK_TRUE, // standardSampleLocations
584 64, // optimalBufferCopyOffsetAlignment
585 64, // optimalBufferCopyRowPitchAlignment
586 256, // nonCoherentAtomSize
587 };
588
589 return limits;
590 }
591
getProperties() const592 const VkPhysicalDeviceProperties &PhysicalDevice::getProperties() const
593 {
594 auto getProperties = [&]() -> VkPhysicalDeviceProperties {
595 VkPhysicalDeviceProperties properties = {
596 API_VERSION,
597 DRIVER_VERSION,
598 VENDOR_ID,
599 DEVICE_ID,
600 VK_PHYSICAL_DEVICE_TYPE_CPU, // deviceType
601 "", // deviceName
602 SWIFTSHADER_UUID, // pipelineCacheUUID
603 getLimits(), // limits
604 {} // sparseProperties
605 };
606
607 // Append Reactor JIT backend name and version
608 snprintf(properties.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE,
609 "%s (%s)", SWIFTSHADER_DEVICE_NAME, rr::BackendName().c_str());
610
611 return properties;
612 };
613
614 static const VkPhysicalDeviceProperties properties = getProperties();
615 return properties;
616 }
617
618 template<typename T>
getIdProperties(T * properties)619 static void getIdProperties(T *properties)
620 {
621 memset(properties->deviceUUID, 0, VK_UUID_SIZE);
622 memset(properties->driverUUID, 0, VK_UUID_SIZE);
623 memset(properties->deviceLUID, 0, VK_LUID_SIZE);
624
625 memcpy(properties->deviceUUID, SWIFTSHADER_UUID, VK_UUID_SIZE);
626 *((uint64_t *)properties->driverUUID) = DRIVER_VERSION;
627
628 properties->deviceNodeMask = 0;
629 properties->deviceLUIDValid = VK_FALSE;
630 }
631
getProperties(VkPhysicalDeviceIDProperties * properties) const632 void PhysicalDevice::getProperties(VkPhysicalDeviceIDProperties *properties) const
633 {
634 getIdProperties(properties);
635 }
636
637 template<typename T>
getMaintenance3Properties(T * properties)638 static void getMaintenance3Properties(T *properties)
639 {
640 properties->maxMemoryAllocationSize = MAX_MEMORY_ALLOCATION_SIZE;
641 properties->maxPerSetDescriptors = 1024;
642 }
643
getProperties(VkPhysicalDeviceMaintenance3Properties * properties) const644 void PhysicalDevice::getProperties(VkPhysicalDeviceMaintenance3Properties *properties) const
645 {
646 getMaintenance3Properties(properties);
647 }
648
649 template<typename T>
getMultiviewProperties(T * properties)650 static void getMultiviewProperties(T *properties)
651 {
652 properties->maxMultiviewViewCount = 6;
653 properties->maxMultiviewInstanceIndex = 1u << 27;
654 }
655
getProperties(VkPhysicalDeviceMultiviewProperties * properties) const656 void PhysicalDevice::getProperties(VkPhysicalDeviceMultiviewProperties *properties) const
657 {
658 getMultiviewProperties(properties);
659 }
660
661 template<typename T>
getPointClippingProperties(T * properties)662 static void getPointClippingProperties(T *properties)
663 {
664 properties->pointClippingBehavior = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES;
665 }
666
getProperties(VkPhysicalDevicePointClippingProperties * properties) const667 void PhysicalDevice::getProperties(VkPhysicalDevicePointClippingProperties *properties) const
668 {
669 getPointClippingProperties(properties);
670 }
671
672 template<typename T>
getProtectedMemoryProperties(T * properties)673 static void getProtectedMemoryProperties(T *properties)
674 {
675 properties->protectedNoFault = VK_FALSE;
676 }
677
getProperties(VkPhysicalDeviceProtectedMemoryProperties * properties) const678 void PhysicalDevice::getProperties(VkPhysicalDeviceProtectedMemoryProperties *properties) const
679 {
680 getProtectedMemoryProperties(properties);
681 }
682
getProperties(VkPhysicalDeviceSubgroupProperties * properties) const683 void PhysicalDevice::getProperties(VkPhysicalDeviceSubgroupProperties *properties) const
684 {
685 properties->subgroupSize = sw::SIMD::Width;
686 properties->supportedStages = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT;
687 properties->supportedOperations =
688 VK_SUBGROUP_FEATURE_BASIC_BIT |
689 VK_SUBGROUP_FEATURE_VOTE_BIT |
690 VK_SUBGROUP_FEATURE_ARITHMETIC_BIT |
691 VK_SUBGROUP_FEATURE_BALLOT_BIT |
692 VK_SUBGROUP_FEATURE_SHUFFLE_BIT |
693 VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT;
694 properties->quadOperationsInAllStages = VK_FALSE;
695 }
696
getProperties(VkPhysicalDeviceVulkan11Properties * properties) const697 void PhysicalDevice::getProperties(VkPhysicalDeviceVulkan11Properties *properties) const
698 {
699 getIdProperties(properties);
700
701 // We can't use templated functions for Vulkan11 & subgroup properties. The names of the
702 // variables in VkPhysicalDeviceSubgroupProperties differ from the names in the Vulkan11
703 // struct.
704 VkPhysicalDeviceSubgroupProperties subgroupProperties = {};
705 getProperties(&subgroupProperties);
706 properties->subgroupSize = subgroupProperties.subgroupSize;
707 properties->subgroupSupportedStages = subgroupProperties.supportedStages;
708 properties->subgroupSupportedOperations = subgroupProperties.supportedOperations;
709 properties->subgroupQuadOperationsInAllStages = subgroupProperties.quadOperationsInAllStages;
710
711 getPointClippingProperties(properties);
712 getMultiviewProperties(properties);
713 getProtectedMemoryProperties(properties);
714 getMaintenance3Properties(properties);
715 }
716
getProperties(const VkExternalMemoryHandleTypeFlagBits * handleType,VkExternalImageFormatProperties * properties) const717 void PhysicalDevice::getProperties(const VkExternalMemoryHandleTypeFlagBits *handleType, VkExternalImageFormatProperties *properties) const
718 {
719 VkExternalMemoryProperties *extMemProperties = &properties->externalMemoryProperties;
720 #if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD
721 if(*handleType == VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT)
722 {
723 extMemProperties->compatibleHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
724 extMemProperties->exportFromImportedHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
725 extMemProperties->externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT;
726 return;
727 }
728 #endif
729 #if SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER
730 if(*handleType == VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)
731 {
732 extMemProperties->compatibleHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
733 extMemProperties->exportFromImportedHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
734 extMemProperties->externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT;
735 return;
736 }
737 #endif
738 #if VK_USE_PLATFORM_FUCHSIA
739 if(*handleType == VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA)
740 {
741 extMemProperties->compatibleHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA;
742 extMemProperties->exportFromImportedHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA;
743 extMemProperties->externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT;
744 return;
745 }
746 #endif
747 extMemProperties->compatibleHandleTypes = 0;
748 extMemProperties->exportFromImportedHandleTypes = 0;
749 extMemProperties->externalMemoryFeatures = 0;
750 }
751
getProperties(const VkExternalMemoryHandleTypeFlagBits * handleType,VkExternalBufferProperties * properties) const752 void PhysicalDevice::getProperties(const VkExternalMemoryHandleTypeFlagBits *handleType, VkExternalBufferProperties *properties) const
753 {
754 VkExternalMemoryProperties *extMemProperties = &properties->externalMemoryProperties;
755 #if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD
756 if(*handleType == VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT)
757 {
758 extMemProperties->compatibleHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
759 extMemProperties->exportFromImportedHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
760 extMemProperties->externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT;
761 return;
762 }
763 #endif
764 #if SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER
765 if(*handleType == VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)
766 {
767 extMemProperties->compatibleHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
768 extMemProperties->exportFromImportedHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
769 extMemProperties->externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT;
770 return;
771 }
772 #endif
773 #if VK_USE_PLATFORM_FUCHSIA
774 if(*handleType == VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA)
775 {
776 extMemProperties->compatibleHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA;
777 extMemProperties->exportFromImportedHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA;
778 extMemProperties->externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT;
779 return;
780 }
781 #endif
782 extMemProperties->compatibleHandleTypes = 0;
783 extMemProperties->exportFromImportedHandleTypes = 0;
784 extMemProperties->externalMemoryFeatures = 0;
785 }
786
getProperties(VkSamplerYcbcrConversionImageFormatProperties * properties) const787 void PhysicalDevice::getProperties(VkSamplerYcbcrConversionImageFormatProperties *properties) const
788 {
789 properties->combinedImageSamplerDescriptorCount = 1; // Need only one descriptor for YCbCr sampling.
790 }
791
792 #ifdef __ANDROID__
getProperties(VkPhysicalDevicePresentationPropertiesANDROID * properties) const793 void PhysicalDevice::getProperties(VkPhysicalDevicePresentationPropertiesANDROID *properties) const
794 {
795 properties->sharedImage = VK_FALSE;
796 }
797
getProperties(const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkAndroidHardwareBufferUsageANDROID * ahbProperties) const798 void PhysicalDevice::getProperties(const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkAndroidHardwareBufferUsageANDROID *ahbProperties) const
799 {
800 // Maps VkImageUsageFlags to AHB usage flags using this table from the Vulkan spec
801 // https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#memory-external-android-hardware-buffer-usage
802
803 // VK_IMAGE_CREATE_PROTECTED_BIT not currently supported.
804 ASSERT((pImageFormatInfo->flags & VK_IMAGE_CREATE_PROTECTED_BIT) == 0);
805
806 // "It must include at least one GPU usage flag (AHARDWAREBUFFER_USAGE_GPU_*), even if none of the corresponding Vulkan usages or flags are requested."
807 uint64_t ahbUsage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
808
809 // Already covered by the default GPU usage flag above.
810 //
811 // if ((vkUsageFlags & VK_IMAGE_USAGE_SAMPLED_BIT) || (vkUsageFlags & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT))
812 // {
813 // ahbUsage |= AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
814 // }
815
816 if((pImageFormatInfo->usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) || (pImageFormatInfo->usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT))
817 {
818 ahbUsage |= AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER;
819 }
820
821 if(pImageFormatInfo->flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)
822 {
823 ahbUsage |= AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP;
824 }
825
826 if(pImageFormatInfo->flags & VK_IMAGE_CREATE_PROTECTED_BIT)
827 {
828 ahbUsage |= AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT;
829 }
830
831 ahbProperties->androidHardwareBufferUsage = ahbUsage;
832 }
833 #endif
834
getProperties(const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties) const835 void PhysicalDevice::getProperties(const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties) const
836 {
837 VkExternalMemoryProperties *properties = &pExternalBufferProperties->externalMemoryProperties;
838
839 #if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD || SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER
840 const VkExternalMemoryHandleTypeFlagBits *handleType = &pExternalBufferInfo->handleType;
841 #endif
842
843 #if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD
844 if(*handleType == VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT)
845 {
846 properties->compatibleHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
847 properties->exportFromImportedHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
848 properties->externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT;
849 return;
850 }
851 #endif
852 #if SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER
853 if(*handleType == VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)
854 {
855 properties->compatibleHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
856 properties->exportFromImportedHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
857 properties->externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT;
858 return;
859 }
860 #endif
861 properties->compatibleHandleTypes = 0;
862 properties->exportFromImportedHandleTypes = 0;
863 properties->externalMemoryFeatures = 0;
864 }
865
getProperties(const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties) const866 void PhysicalDevice::getProperties(const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties) const
867 {
868 pExternalFenceProperties->compatibleHandleTypes = 0;
869 pExternalFenceProperties->exportFromImportedHandleTypes = 0;
870 pExternalFenceProperties->externalFenceFeatures = 0;
871 }
872
getProperties(const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties) const873 void PhysicalDevice::getProperties(const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties) const
874 {
875 for(const auto *nextInfo = reinterpret_cast<const VkBaseInStructure *>(pExternalSemaphoreInfo->pNext);
876 nextInfo != nullptr; nextInfo = nextInfo->pNext)
877 {
878 switch(nextInfo->sType)
879 {
880 case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
881 {
882 const auto *tlsInfo = reinterpret_cast<const VkSemaphoreTypeCreateInfo *>(nextInfo);
883 // Timeline Semaphore does not support external semaphore
884 if(tlsInfo->semaphoreType == VK_SEMAPHORE_TYPE_TIMELINE)
885 {
886 pExternalSemaphoreProperties->compatibleHandleTypes = 0;
887 pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0;
888 pExternalSemaphoreProperties->externalSemaphoreFeatures = 0;
889 return;
890 }
891 }
892 break;
893 default:
894 WARN("nextInfo->sType = %s", vk::Stringify(nextInfo->sType).c_str());
895 break;
896 }
897 }
898
899 #if SWIFTSHADER_EXTERNAL_SEMAPHORE_OPAQUE_FD
900 if(pExternalSemaphoreInfo->handleType == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT)
901 {
902 pExternalSemaphoreProperties->compatibleHandleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
903 pExternalSemaphoreProperties->exportFromImportedHandleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
904 pExternalSemaphoreProperties->externalSemaphoreFeatures = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT | VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT;
905 return;
906 }
907 #endif
908 #if VK_USE_PLATFORM_FUCHSIA
909 if(pExternalSemaphoreInfo->handleType == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA)
910 {
911 pExternalSemaphoreProperties->compatibleHandleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA;
912 pExternalSemaphoreProperties->exportFromImportedHandleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA;
913 pExternalSemaphoreProperties->externalSemaphoreFeatures = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT | VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT;
914 return;
915 }
916 #endif
917 pExternalSemaphoreProperties->compatibleHandleTypes = 0;
918 pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0;
919 pExternalSemaphoreProperties->externalSemaphoreFeatures = 0;
920 }
921
getProperties(VkPhysicalDeviceExternalMemoryHostPropertiesEXT * properties) const922 void PhysicalDevice::getProperties(VkPhysicalDeviceExternalMemoryHostPropertiesEXT *properties) const
923 {
924 properties->minImportedHostPointerAlignment = REQUIRED_MEMORY_ALIGNMENT;
925 }
926
927 template<typename T>
getDriverProperties(T * properties)928 static void getDriverProperties(T *properties)
929 {
930 properties->driverID = VK_DRIVER_ID_GOOGLE_SWIFTSHADER_KHR;
931 strcpy(properties->driverName, "SwiftShader driver");
932 strcpy(properties->driverInfo, "");
933 properties->conformanceVersion = { 1, 1, 3, 3 };
934 }
935
getProperties(VkPhysicalDeviceDriverProperties * properties) const936 void PhysicalDevice::getProperties(VkPhysicalDeviceDriverProperties *properties) const
937 {
938 getDriverProperties(properties);
939 }
940
getProperties(VkPhysicalDeviceLineRasterizationPropertiesEXT * properties) const941 void PhysicalDevice::getProperties(VkPhysicalDeviceLineRasterizationPropertiesEXT *properties) const
942 {
943 properties->lineSubPixelPrecisionBits = vk::SUBPIXEL_PRECISION_BITS;
944 }
945
getProperties(VkPhysicalDeviceProvokingVertexPropertiesEXT * properties) const946 void PhysicalDevice::getProperties(VkPhysicalDeviceProvokingVertexPropertiesEXT *properties) const
947 {
948 properties->provokingVertexModePerPipeline = VK_TRUE;
949 }
950
951 template<typename T>
getFloatControlsProperties(T * properties)952 static void getFloatControlsProperties(T *properties)
953 {
954 // The spec states:
955 // shaderSignedZeroInfNanPreserveFloat32 is a boolean value indicating whether
956 // sign of a zero, Nans and +/-infinity can be preserved in 32-bit floating-point
957 // computations. It also indicates whether the SignedZeroInfNanPreserve execution
958 // mode can be used for 32-bit floating-point types.
959 //
960 // There are similar clauses for all the shader* bools present here.
961 //
962 // It does not state that an implementation must report its default behavior using
963 // these variables. At this time SwiftShader does not expose any preserve, denormal,
964 // or rounding controls.
965 properties->denormBehaviorIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE;
966 properties->roundingModeIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE;
967 properties->shaderSignedZeroInfNanPreserveFloat16 = VK_FALSE;
968 properties->shaderSignedZeroInfNanPreserveFloat32 = VK_FALSE;
969 properties->shaderSignedZeroInfNanPreserveFloat64 = VK_FALSE;
970 properties->shaderDenormPreserveFloat16 = VK_FALSE;
971 properties->shaderDenormPreserveFloat32 = VK_FALSE;
972 properties->shaderDenormPreserveFloat64 = VK_FALSE;
973 properties->shaderDenormFlushToZeroFloat16 = VK_FALSE;
974 properties->shaderDenormFlushToZeroFloat32 = VK_FALSE;
975 properties->shaderDenormFlushToZeroFloat64 = VK_FALSE;
976 properties->shaderRoundingModeRTZFloat16 = VK_FALSE;
977 properties->shaderRoundingModeRTZFloat32 = VK_FALSE;
978 properties->shaderRoundingModeRTZFloat64 = VK_FALSE;
979 properties->shaderRoundingModeRTEFloat16 = VK_FALSE;
980 properties->shaderRoundingModeRTEFloat32 = VK_FALSE;
981 properties->shaderRoundingModeRTEFloat64 = VK_FALSE;
982 }
983
getProperties(VkPhysicalDeviceFloatControlsProperties * properties) const984 void PhysicalDevice::getProperties(VkPhysicalDeviceFloatControlsProperties *properties) const
985 {
986 getFloatControlsProperties(properties);
987 }
988
989 template<typename T>
getDescriptorIndexingProperties(T * properties)990 static void getDescriptorIndexingProperties(T *properties)
991 {
992 // "The UpdateAfterBind descriptor limits must each be greater than or equal to
993 // the corresponding non-UpdateAfterBind limit."
994 const VkPhysicalDeviceLimits &limits = PhysicalDevice::getLimits();
995
996 properties->maxUpdateAfterBindDescriptorsInAllPools = 0;
997 properties->shaderUniformBufferArrayNonUniformIndexingNative = VK_FALSE;
998 properties->shaderSampledImageArrayNonUniformIndexingNative = VK_FALSE;
999 properties->shaderStorageBufferArrayNonUniformIndexingNative = VK_FALSE;
1000 properties->shaderStorageImageArrayNonUniformIndexingNative = VK_FALSE;
1001 properties->shaderInputAttachmentArrayNonUniformIndexingNative = VK_FALSE;
1002 properties->robustBufferAccessUpdateAfterBind = VK_FALSE;
1003 properties->quadDivergentImplicitLod = VK_FALSE;
1004 properties->maxPerStageDescriptorUpdateAfterBindSamplers = limits.maxPerStageDescriptorSamplers;
1005 properties->maxPerStageDescriptorUpdateAfterBindUniformBuffers = limits.maxPerStageDescriptorUniformBuffers;
1006 properties->maxPerStageDescriptorUpdateAfterBindStorageBuffers = limits.maxPerStageDescriptorStorageBuffers;
1007 properties->maxPerStageDescriptorUpdateAfterBindSampledImages = limits.maxPerStageDescriptorSampledImages;
1008 properties->maxPerStageDescriptorUpdateAfterBindStorageImages = limits.maxPerStageDescriptorStorageImages;
1009 properties->maxPerStageDescriptorUpdateAfterBindInputAttachments = limits.maxPerStageDescriptorInputAttachments;
1010 properties->maxPerStageUpdateAfterBindResources = limits.maxPerStageResources;
1011 properties->maxDescriptorSetUpdateAfterBindSamplers = limits.maxDescriptorSetSamplers;
1012 properties->maxDescriptorSetUpdateAfterBindUniformBuffers = limits.maxDescriptorSetUniformBuffers;
1013 properties->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = limits.maxDescriptorSetUniformBuffersDynamic;
1014 properties->maxDescriptorSetUpdateAfterBindStorageBuffers = limits.maxDescriptorSetStorageBuffers;
1015 properties->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = limits.maxDescriptorSetStorageBuffersDynamic;
1016 properties->maxDescriptorSetUpdateAfterBindSampledImages = limits.maxDescriptorSetSampledImages;
1017 properties->maxDescriptorSetUpdateAfterBindStorageImages = limits.maxDescriptorSetStorageImages;
1018 properties->maxDescriptorSetUpdateAfterBindInputAttachments = limits.maxDescriptorSetInputAttachments;
1019 }
1020
getProperties(VkPhysicalDeviceDescriptorIndexingProperties * properties) const1021 void PhysicalDevice::getProperties(VkPhysicalDeviceDescriptorIndexingProperties *properties) const
1022 {
1023 getDescriptorIndexingProperties(properties);
1024 }
1025
1026 template<typename T>
getDepthStencilResolveProperties(T * properties)1027 static void getDepthStencilResolveProperties(T *properties)
1028 {
1029 properties->supportedDepthResolveModes = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT | VK_RESOLVE_MODE_NONE;
1030 properties->supportedStencilResolveModes = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT | VK_RESOLVE_MODE_NONE;
1031 properties->independentResolveNone = VK_TRUE;
1032 properties->independentResolve = VK_TRUE;
1033 }
1034
getProperties(VkPhysicalDeviceDepthStencilResolveProperties * properties) const1035 void PhysicalDevice::getProperties(VkPhysicalDeviceDepthStencilResolveProperties *properties) const
1036 {
1037 getDepthStencilResolveProperties(properties);
1038 }
1039
getProperties(VkPhysicalDeviceCustomBorderColorPropertiesEXT * properties) const1040 void PhysicalDevice::getProperties(VkPhysicalDeviceCustomBorderColorPropertiesEXT *properties) const
1041 {
1042 properties->maxCustomBorderColorSamplers = MAX_SAMPLER_ALLOCATION_COUNT;
1043 }
1044
getProperties(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT * properties) const1045 void PhysicalDevice::getProperties(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *properties) const
1046 {
1047 // Note: advancedBlendMaxColorAttachments could already support sw::MAX_COLOR_BUFFERS as is,
1048 // but using a value of 1 is enough for ANGLE to implement GL_KHR_blend_equation_advanced
1049 properties->advancedBlendMaxColorAttachments = 1;
1050 properties->advancedBlendIndependentBlend = VK_FALSE;
1051 properties->advancedBlendNonPremultipliedSrcColor = VK_FALSE;
1052 properties->advancedBlendNonPremultipliedDstColor = VK_FALSE;
1053 properties->advancedBlendCorrelatedOverlap = VK_FALSE;
1054 properties->advancedBlendAllOperations = VK_FALSE;
1055 }
1056
1057 template<typename T>
getSamplerFilterMinmaxProperties(T * properties)1058 static void getSamplerFilterMinmaxProperties(T *properties)
1059 {
1060 properties->filterMinmaxSingleComponentFormats = VK_FALSE;
1061 properties->filterMinmaxImageComponentMapping = VK_FALSE;
1062 }
1063
getProperties(VkPhysicalDeviceSamplerFilterMinmaxProperties * properties) const1064 void PhysicalDevice::getProperties(VkPhysicalDeviceSamplerFilterMinmaxProperties *properties) const
1065 {
1066 getSamplerFilterMinmaxProperties(properties);
1067 }
1068
1069 template<typename T>
getTimelineSemaphoreProperties(T * properties)1070 static void getTimelineSemaphoreProperties(T *properties)
1071 {
1072 // Our implementation of Timeline Semaphores allows the timeline to advance to any value from any value.
1073 properties->maxTimelineSemaphoreValueDifference = (uint64_t)-1;
1074 }
1075
getProperties(VkPhysicalDeviceTimelineSemaphoreProperties * properties) const1076 void PhysicalDevice::getProperties(VkPhysicalDeviceTimelineSemaphoreProperties *properties) const
1077 {
1078 getTimelineSemaphoreProperties(properties);
1079 }
1080
getProperties(VkPhysicalDeviceVulkan12Properties * properties) const1081 void PhysicalDevice::getProperties(VkPhysicalDeviceVulkan12Properties *properties) const
1082 {
1083 getDriverProperties(properties);
1084 getFloatControlsProperties(properties);
1085 getDescriptorIndexingProperties(properties);
1086 getDepthStencilResolveProperties(properties);
1087 getSamplerFilterMinmaxProperties(properties);
1088 getTimelineSemaphoreProperties(properties);
1089 properties->framebufferIntegerColorSampleCounts = VK_SAMPLE_COUNT_1_BIT;
1090 }
1091
hasFeatures(const VkPhysicalDeviceFeatures & requestedFeatures) const1092 bool PhysicalDevice::hasFeatures(const VkPhysicalDeviceFeatures &requestedFeatures) const
1093 {
1094 const VkPhysicalDeviceFeatures &supportedFeatures = getFeatures();
1095 const VkBool32 *supportedFeature = reinterpret_cast<const VkBool32 *>(&supportedFeatures);
1096 const VkBool32 *requestedFeature = reinterpret_cast<const VkBool32 *>(&requestedFeatures);
1097 constexpr auto featureCount = sizeof(VkPhysicalDeviceFeatures) / sizeof(VkBool32);
1098
1099 for(unsigned int i = 0; i < featureCount; i++)
1100 {
1101 if((requestedFeature[i] != VK_FALSE) && (supportedFeature[i] == VK_FALSE))
1102 {
1103 return false;
1104 }
1105 }
1106
1107 return true;
1108 }
1109
1110 // CheckFeature returns false if requested is asking for a feature that is not supported
1111 #define CheckFeature(requested, supported, feature) (requested->feature == VK_FALSE || supported.feature == VK_TRUE)
1112
1113 template<typename T>
getSupportedFeatures(const T * requested) const1114 T PhysicalDevice::getSupportedFeatures(const T *requested) const
1115 {
1116 VkPhysicalDeviceFeatures2 features;
1117 features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
1118 T supported;
1119 supported.sType = requested->sType;
1120 supported.pNext = nullptr;
1121 features.pNext = &supported;
1122 getFeatures2(&features);
1123 return supported;
1124 }
1125
hasExtendedFeatures(const VkPhysicalDeviceLineRasterizationFeaturesEXT * requested) const1126 bool PhysicalDevice::hasExtendedFeatures(const VkPhysicalDeviceLineRasterizationFeaturesEXT *requested) const
1127 {
1128 auto supported = getSupportedFeatures(requested);
1129
1130 return CheckFeature(requested, supported, rectangularLines) &&
1131 CheckFeature(requested, supported, bresenhamLines) &&
1132 CheckFeature(requested, supported, smoothLines) &&
1133 CheckFeature(requested, supported, stippledRectangularLines) &&
1134 CheckFeature(requested, supported, stippledBresenhamLines) &&
1135 CheckFeature(requested, supported, stippledSmoothLines);
1136 }
1137
hasExtendedFeatures(const VkPhysicalDeviceProvokingVertexFeaturesEXT * requested) const1138 bool PhysicalDevice::hasExtendedFeatures(const VkPhysicalDeviceProvokingVertexFeaturesEXT *requested) const
1139 {
1140 auto supported = getSupportedFeatures(requested);
1141
1142 return CheckFeature(requested, supported, provokingVertexLast) &&
1143 CheckFeature(requested, supported, transformFeedbackPreservesProvokingVertex);
1144 }
1145
hasExtendedFeatures(const VkPhysicalDeviceVulkan11Features * requested) const1146 bool PhysicalDevice::hasExtendedFeatures(const VkPhysicalDeviceVulkan11Features *requested) const
1147 {
1148 auto supported = getSupportedFeatures(requested);
1149
1150 return CheckFeature(requested, supported, storageBuffer16BitAccess) &&
1151 CheckFeature(requested, supported, uniformAndStorageBuffer16BitAccess) &&
1152 CheckFeature(requested, supported, storagePushConstant16) &&
1153 CheckFeature(requested, supported, storageInputOutput16) &&
1154 CheckFeature(requested, supported, multiview) &&
1155 CheckFeature(requested, supported, multiviewGeometryShader) &&
1156 CheckFeature(requested, supported, multiviewTessellationShader) &&
1157 CheckFeature(requested, supported, variablePointersStorageBuffer) &&
1158 CheckFeature(requested, supported, variablePointers) &&
1159 CheckFeature(requested, supported, protectedMemory) &&
1160 CheckFeature(requested, supported, samplerYcbcrConversion) &&
1161 CheckFeature(requested, supported, shaderDrawParameters);
1162 }
1163
hasExtendedFeatures(const VkPhysicalDeviceVulkan12Features * requested) const1164 bool PhysicalDevice::hasExtendedFeatures(const VkPhysicalDeviceVulkan12Features *requested) const
1165 {
1166 auto supported = getSupportedFeatures(requested);
1167
1168 return CheckFeature(requested, supported, samplerMirrorClampToEdge) &&
1169 CheckFeature(requested, supported, drawIndirectCount) &&
1170 CheckFeature(requested, supported, storageBuffer8BitAccess) &&
1171 CheckFeature(requested, supported, uniformAndStorageBuffer8BitAccess) &&
1172 CheckFeature(requested, supported, storagePushConstant8) &&
1173 CheckFeature(requested, supported, shaderBufferInt64Atomics) &&
1174 CheckFeature(requested, supported, shaderSharedInt64Atomics) &&
1175 CheckFeature(requested, supported, shaderFloat16) &&
1176 CheckFeature(requested, supported, shaderInt8) &&
1177 CheckFeature(requested, supported, descriptorIndexing) &&
1178 CheckFeature(requested, supported, shaderInputAttachmentArrayDynamicIndexing) &&
1179 CheckFeature(requested, supported, shaderUniformTexelBufferArrayDynamicIndexing) &&
1180 CheckFeature(requested, supported, shaderStorageTexelBufferArrayDynamicIndexing) &&
1181 CheckFeature(requested, supported, shaderUniformBufferArrayNonUniformIndexing) &&
1182 CheckFeature(requested, supported, shaderSampledImageArrayNonUniformIndexing) &&
1183 CheckFeature(requested, supported, shaderStorageBufferArrayNonUniformIndexing) &&
1184 CheckFeature(requested, supported, shaderStorageImageArrayNonUniformIndexing) &&
1185 CheckFeature(requested, supported, shaderInputAttachmentArrayNonUniformIndexing) &&
1186 CheckFeature(requested, supported, shaderUniformTexelBufferArrayNonUniformIndexing) &&
1187 CheckFeature(requested, supported, shaderStorageTexelBufferArrayNonUniformIndexing) &&
1188 CheckFeature(requested, supported, descriptorBindingUniformBufferUpdateAfterBind) &&
1189 CheckFeature(requested, supported, descriptorBindingSampledImageUpdateAfterBind) &&
1190 CheckFeature(requested, supported, descriptorBindingStorageImageUpdateAfterBind) &&
1191 CheckFeature(requested, supported, descriptorBindingStorageBufferUpdateAfterBind) &&
1192 CheckFeature(requested, supported, descriptorBindingUniformTexelBufferUpdateAfterBind) &&
1193 CheckFeature(requested, supported, descriptorBindingStorageTexelBufferUpdateAfterBind) &&
1194 CheckFeature(requested, supported, descriptorBindingUpdateUnusedWhilePending) &&
1195 CheckFeature(requested, supported, descriptorBindingPartiallyBound) &&
1196 CheckFeature(requested, supported, descriptorBindingVariableDescriptorCount) &&
1197 CheckFeature(requested, supported, runtimeDescriptorArray) &&
1198 CheckFeature(requested, supported, samplerFilterMinmax) &&
1199 CheckFeature(requested, supported, scalarBlockLayout) &&
1200 CheckFeature(requested, supported, imagelessFramebuffer) &&
1201 CheckFeature(requested, supported, uniformBufferStandardLayout) &&
1202 CheckFeature(requested, supported, shaderSubgroupExtendedTypes) &&
1203 CheckFeature(requested, supported, separateDepthStencilLayouts) &&
1204 CheckFeature(requested, supported, hostQueryReset) &&
1205 CheckFeature(requested, supported, timelineSemaphore) &&
1206 CheckFeature(requested, supported, bufferDeviceAddress) &&
1207 CheckFeature(requested, supported, bufferDeviceAddressCaptureReplay) &&
1208 CheckFeature(requested, supported, bufferDeviceAddressMultiDevice) &&
1209 CheckFeature(requested, supported, vulkanMemoryModel) &&
1210 CheckFeature(requested, supported, vulkanMemoryModelDeviceScope) &&
1211 CheckFeature(requested, supported, vulkanMemoryModelAvailabilityVisibilityChains) &&
1212 CheckFeature(requested, supported, shaderOutputViewportIndex) &&
1213 CheckFeature(requested, supported, shaderOutputLayer) &&
1214 CheckFeature(requested, supported, subgroupBroadcastDynamicId);
1215 }
1216
hasExtendedFeatures(const VkPhysicalDeviceDepthClipEnableFeaturesEXT * requested) const1217 bool PhysicalDevice::hasExtendedFeatures(const VkPhysicalDeviceDepthClipEnableFeaturesEXT *requested) const
1218 {
1219 auto supported = getSupportedFeatures(requested);
1220
1221 return CheckFeature(requested, supported, depthClipEnable);
1222 }
1223
hasExtendedFeatures(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT * requested) const1224 bool PhysicalDevice::hasExtendedFeatures(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *requested) const
1225 {
1226 auto supported = getSupportedFeatures(requested);
1227
1228 return CheckFeature(requested, supported, advancedBlendCoherentOperations);
1229 }
1230 #undef CheckFeature
1231
GetFormatProperties(Format format,VkFormatProperties * pFormatProperties)1232 void PhysicalDevice::GetFormatProperties(Format format, VkFormatProperties *pFormatProperties)
1233 {
1234 pFormatProperties->linearTilingFeatures = 0; // Unsupported format
1235 pFormatProperties->optimalTilingFeatures = 0; // Unsupported format
1236 pFormatProperties->bufferFeatures = 0; // Unsupported format
1237
1238 switch(format)
1239 {
1240 // Formats which can be sampled *and* filtered
1241 case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
1242 case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
1243 case VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT:
1244 case VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT:
1245 case VK_FORMAT_R5G6B5_UNORM_PACK16:
1246 case VK_FORMAT_B5G6R5_UNORM_PACK16:
1247 case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
1248 case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
1249 case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
1250 case VK_FORMAT_R8_UNORM:
1251 case VK_FORMAT_R8_SRGB:
1252 case VK_FORMAT_R8_SNORM:
1253 case VK_FORMAT_R8G8_UNORM:
1254 case VK_FORMAT_R8G8_SRGB:
1255 case VK_FORMAT_R8G8_SNORM:
1256 case VK_FORMAT_R8G8B8A8_UNORM:
1257 case VK_FORMAT_R8G8B8A8_SNORM:
1258 case VK_FORMAT_R8G8B8A8_SRGB:
1259 case VK_FORMAT_B8G8R8A8_UNORM:
1260 case VK_FORMAT_B8G8R8A8_SRGB:
1261 case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
1262 case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
1263 case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
1264 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
1265 case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
1266 case VK_FORMAT_R16_UNORM:
1267 case VK_FORMAT_R16_SNORM:
1268 case VK_FORMAT_R16_SFLOAT:
1269 case VK_FORMAT_R16G16_UNORM:
1270 case VK_FORMAT_R16G16_SNORM:
1271 case VK_FORMAT_R16G16_SFLOAT:
1272 case VK_FORMAT_R16G16B16A16_UNORM:
1273 case VK_FORMAT_R16G16B16A16_SNORM:
1274 case VK_FORMAT_R16G16B16A16_SFLOAT:
1275 case VK_FORMAT_R32_SFLOAT:
1276 case VK_FORMAT_R32G32_SFLOAT:
1277 case VK_FORMAT_R32G32B32A32_SFLOAT:
1278 case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
1279 case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
1280 case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
1281 case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
1282 case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
1283 case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
1284 case VK_FORMAT_BC2_UNORM_BLOCK:
1285 case VK_FORMAT_BC2_SRGB_BLOCK:
1286 case VK_FORMAT_BC3_UNORM_BLOCK:
1287 case VK_FORMAT_BC3_SRGB_BLOCK:
1288 case VK_FORMAT_BC4_UNORM_BLOCK:
1289 case VK_FORMAT_BC4_SNORM_BLOCK:
1290 case VK_FORMAT_BC5_UNORM_BLOCK:
1291 case VK_FORMAT_BC5_SNORM_BLOCK:
1292 case VK_FORMAT_BC6H_UFLOAT_BLOCK:
1293 case VK_FORMAT_BC6H_SFLOAT_BLOCK:
1294 case VK_FORMAT_BC7_UNORM_BLOCK:
1295 case VK_FORMAT_BC7_SRGB_BLOCK:
1296 case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
1297 case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
1298 case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
1299 case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
1300 case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
1301 case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
1302 case VK_FORMAT_EAC_R11_UNORM_BLOCK:
1303 case VK_FORMAT_EAC_R11_SNORM_BLOCK:
1304 case VK_FORMAT_EAC_R11G11_UNORM_BLOCK:
1305 case VK_FORMAT_EAC_R11G11_SNORM_BLOCK:
1306 #ifdef SWIFTSHADER_ENABLE_ASTC
1307 case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
1308 case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
1309 case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
1310 case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
1311 case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
1312 case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
1313 case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
1314 case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
1315 case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
1316 case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
1317 case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
1318 case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
1319 case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
1320 case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
1321 case VK_FORMAT_ASTC_4x4_SRGB_BLOCK:
1322 case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
1323 case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
1324 case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
1325 case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
1326 case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
1327 case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
1328 case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
1329 case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
1330 case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
1331 case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
1332 case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
1333 case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
1334 case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
1335 #endif
1336 case VK_FORMAT_D16_UNORM:
1337 case VK_FORMAT_D32_SFLOAT:
1338 case VK_FORMAT_D32_SFLOAT_S8_UINT:
1339 pFormatProperties->optimalTilingFeatures |=
1340 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
1341 // [[fallthrough]]
1342
1343 // Formats which can be sampled, but don't support filtering
1344 case VK_FORMAT_R8_UINT:
1345 case VK_FORMAT_R8_SINT:
1346 case VK_FORMAT_R8G8_UINT:
1347 case VK_FORMAT_R8G8_SINT:
1348 case VK_FORMAT_R8G8B8A8_UINT:
1349 case VK_FORMAT_R8G8B8A8_SINT:
1350 case VK_FORMAT_A8B8G8R8_UINT_PACK32:
1351 case VK_FORMAT_A8B8G8R8_SINT_PACK32:
1352 case VK_FORMAT_A2B10G10R10_UINT_PACK32:
1353 case VK_FORMAT_A2R10G10B10_UINT_PACK32:
1354 case VK_FORMAT_R16_UINT:
1355 case VK_FORMAT_R16_SINT:
1356 case VK_FORMAT_R16G16_UINT:
1357 case VK_FORMAT_R16G16_SINT:
1358 case VK_FORMAT_R16G16B16A16_UINT:
1359 case VK_FORMAT_R16G16B16A16_SINT:
1360 case VK_FORMAT_R32_UINT:
1361 case VK_FORMAT_R32_SINT:
1362 case VK_FORMAT_R32G32_UINT:
1363 case VK_FORMAT_R32G32_SINT:
1364 case VK_FORMAT_R32G32B32A32_UINT:
1365 case VK_FORMAT_R32G32B32A32_SINT:
1366 case VK_FORMAT_S8_UINT:
1367 pFormatProperties->optimalTilingFeatures |=
1368 VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT |
1369 VK_FORMAT_FEATURE_BLIT_SRC_BIT |
1370 VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
1371 VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
1372 break;
1373
1374 // YCbCr formats:
1375 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
1376 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
1377 pFormatProperties->optimalTilingFeatures |=
1378 VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT |
1379 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT |
1380 VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
1381 VK_FORMAT_FEATURE_TRANSFER_DST_BIT |
1382 VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT;
1383 break;
1384 default:
1385 break;
1386 }
1387
1388 switch(format)
1389 {
1390 // Vulkan 1.0 mandatory storage image formats supporting atomic operations
1391 case VK_FORMAT_R32_UINT:
1392 case VK_FORMAT_R32_SINT:
1393 pFormatProperties->optimalTilingFeatures |=
1394 VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT;
1395 pFormatProperties->bufferFeatures |=
1396 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT;
1397 // [[fallthrough]]
1398 // Vulkan 1.0 mandatory storage image formats
1399 case VK_FORMAT_R8G8B8A8_UNORM:
1400 case VK_FORMAT_R8G8B8A8_SNORM:
1401 case VK_FORMAT_R8G8B8A8_UINT:
1402 case VK_FORMAT_R8G8B8A8_SINT:
1403 case VK_FORMAT_R16G16B16A16_UINT:
1404 case VK_FORMAT_R16G16B16A16_SINT:
1405 case VK_FORMAT_R16G16B16A16_SFLOAT:
1406 case VK_FORMAT_R32_SFLOAT:
1407 case VK_FORMAT_R32G32_UINT:
1408 case VK_FORMAT_R32G32_SINT:
1409 case VK_FORMAT_R32G32_SFLOAT:
1410 case VK_FORMAT_R32G32B32A32_UINT:
1411 case VK_FORMAT_R32G32B32A32_SINT:
1412 case VK_FORMAT_R32G32B32A32_SFLOAT:
1413 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
1414 case VK_FORMAT_A2B10G10R10_UINT_PACK32:
1415 // Vulkan 1.0 shaderStorageImageExtendedFormats
1416 case VK_FORMAT_R16G16_SFLOAT:
1417 case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
1418 case VK_FORMAT_R16_SFLOAT:
1419 case VK_FORMAT_R16G16B16A16_UNORM:
1420 case VK_FORMAT_R16G16_UNORM:
1421 case VK_FORMAT_R8G8_UNORM:
1422 case VK_FORMAT_R16_UNORM:
1423 case VK_FORMAT_R8_UNORM:
1424 case VK_FORMAT_R16G16B16A16_SNORM:
1425 case VK_FORMAT_R16G16_SNORM:
1426 case VK_FORMAT_R8G8_SNORM:
1427 case VK_FORMAT_R16_SNORM:
1428 case VK_FORMAT_R8_SNORM:
1429 case VK_FORMAT_R16G16_SINT:
1430 case VK_FORMAT_R8G8_SINT:
1431 case VK_FORMAT_R16_SINT:
1432 case VK_FORMAT_R8_SINT:
1433 case VK_FORMAT_R16G16_UINT:
1434 case VK_FORMAT_R8G8_UINT:
1435 case VK_FORMAT_R16_UINT:
1436 case VK_FORMAT_R8_UINT:
1437 // Additional formats not listed under "Formats without shader storage format"
1438 case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
1439 case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
1440 case VK_FORMAT_A8B8G8R8_UINT_PACK32:
1441 case VK_FORMAT_A8B8G8R8_SINT_PACK32:
1442 case VK_FORMAT_B8G8R8A8_UNORM:
1443 case VK_FORMAT_B8G8R8A8_SRGB:
1444 pFormatProperties->optimalTilingFeatures |=
1445 VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT;
1446 pFormatProperties->bufferFeatures |=
1447 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT;
1448 break;
1449 default:
1450 break;
1451 }
1452
1453 switch(format)
1454 {
1455 case VK_FORMAT_R5G6B5_UNORM_PACK16:
1456 case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
1457 case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
1458 case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
1459 case VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT:
1460 case VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT:
1461 case VK_FORMAT_B5G6R5_UNORM_PACK16:
1462 case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
1463 case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
1464 case VK_FORMAT_R8_UNORM:
1465 case VK_FORMAT_R8G8_UNORM:
1466 case VK_FORMAT_R8G8B8A8_UNORM:
1467 case VK_FORMAT_R8G8B8A8_SRGB:
1468 case VK_FORMAT_B8G8R8A8_UNORM:
1469 case VK_FORMAT_B8G8R8A8_SRGB:
1470 case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
1471 case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
1472 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
1473 case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
1474 case VK_FORMAT_R16_SFLOAT:
1475 case VK_FORMAT_R16G16_SFLOAT:
1476 case VK_FORMAT_R16G16B16A16_SFLOAT:
1477 case VK_FORMAT_R32_SFLOAT:
1478 case VK_FORMAT_R32G32_SFLOAT:
1479 case VK_FORMAT_R32G32B32A32_SFLOAT:
1480 case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
1481 case VK_FORMAT_R8_UINT:
1482 case VK_FORMAT_R8_SINT:
1483 case VK_FORMAT_R8G8_UINT:
1484 case VK_FORMAT_R8G8_SINT:
1485 case VK_FORMAT_R8G8B8A8_UINT:
1486 case VK_FORMAT_R8G8B8A8_SINT:
1487 case VK_FORMAT_A8B8G8R8_UINT_PACK32:
1488 case VK_FORMAT_A8B8G8R8_SINT_PACK32:
1489 case VK_FORMAT_A2B10G10R10_UINT_PACK32:
1490 case VK_FORMAT_A2R10G10B10_UINT_PACK32:
1491 case VK_FORMAT_R16_UNORM:
1492 case VK_FORMAT_R16_UINT:
1493 case VK_FORMAT_R16_SINT:
1494 case VK_FORMAT_R16G16_UNORM:
1495 case VK_FORMAT_R16G16_UINT:
1496 case VK_FORMAT_R16G16_SINT:
1497 case VK_FORMAT_R16G16B16A16_UNORM:
1498 case VK_FORMAT_R16G16B16A16_UINT:
1499 case VK_FORMAT_R16G16B16A16_SINT:
1500 case VK_FORMAT_R32_UINT:
1501 case VK_FORMAT_R32_SINT:
1502 case VK_FORMAT_R32G32_UINT:
1503 case VK_FORMAT_R32G32_SINT:
1504 case VK_FORMAT_R32G32B32A32_UINT:
1505 case VK_FORMAT_R32G32B32A32_SINT:
1506 pFormatProperties->optimalTilingFeatures |=
1507 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT |
1508 VK_FORMAT_FEATURE_BLIT_DST_BIT;
1509 break;
1510 case VK_FORMAT_S8_UINT:
1511 case VK_FORMAT_D16_UNORM:
1512 case VK_FORMAT_D32_SFLOAT: // Note: either VK_FORMAT_D32_SFLOAT or VK_FORMAT_X8_D24_UNORM_PACK32 must be supported
1513 case VK_FORMAT_D32_SFLOAT_S8_UINT: // Note: either VK_FORMAT_D24_UNORM_S8_UINT or VK_FORMAT_D32_SFLOAT_S8_UINT must be supported
1514 pFormatProperties->optimalTilingFeatures |=
1515 VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT;
1516 break;
1517 default:
1518 break;
1519 }
1520
1521 if(format.supportsColorAttachmentBlend())
1522 {
1523 pFormatProperties->optimalTilingFeatures |=
1524 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT;
1525 }
1526
1527 switch(format)
1528 {
1529 case VK_FORMAT_R8_UNORM:
1530 case VK_FORMAT_R8_SNORM:
1531 case VK_FORMAT_R8_USCALED:
1532 case VK_FORMAT_R8_SSCALED:
1533 case VK_FORMAT_R8_UINT:
1534 case VK_FORMAT_R8_SINT:
1535 case VK_FORMAT_R8G8_UNORM:
1536 case VK_FORMAT_R8G8_SNORM:
1537 case VK_FORMAT_R8G8_USCALED:
1538 case VK_FORMAT_R8G8_SSCALED:
1539 case VK_FORMAT_R8G8_UINT:
1540 case VK_FORMAT_R8G8_SINT:
1541 case VK_FORMAT_R8G8B8A8_UNORM:
1542 case VK_FORMAT_R8G8B8A8_SNORM:
1543 case VK_FORMAT_R8G8B8A8_USCALED:
1544 case VK_FORMAT_R8G8B8A8_SSCALED:
1545 case VK_FORMAT_R8G8B8A8_UINT:
1546 case VK_FORMAT_R8G8B8A8_SINT:
1547 case VK_FORMAT_B8G8R8A8_UNORM:
1548 case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
1549 case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
1550 case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
1551 case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
1552 case VK_FORMAT_A8B8G8R8_UINT_PACK32:
1553 case VK_FORMAT_A8B8G8R8_SINT_PACK32:
1554 case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
1555 case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
1556 case VK_FORMAT_A2R10G10B10_UINT_PACK32:
1557 case VK_FORMAT_A2R10G10B10_SINT_PACK32:
1558 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
1559 case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
1560 case VK_FORMAT_A2B10G10R10_UINT_PACK32:
1561 case VK_FORMAT_A2B10G10R10_SINT_PACK32:
1562 case VK_FORMAT_R16_UNORM:
1563 case VK_FORMAT_R16_SNORM:
1564 case VK_FORMAT_R16_USCALED:
1565 case VK_FORMAT_R16_SSCALED:
1566 case VK_FORMAT_R16_UINT:
1567 case VK_FORMAT_R16_SINT:
1568 case VK_FORMAT_R16_SFLOAT:
1569 case VK_FORMAT_R16G16_UNORM:
1570 case VK_FORMAT_R16G16_SNORM:
1571 case VK_FORMAT_R16G16_USCALED:
1572 case VK_FORMAT_R16G16_SSCALED:
1573 case VK_FORMAT_R16G16_UINT:
1574 case VK_FORMAT_R16G16_SINT:
1575 case VK_FORMAT_R16G16_SFLOAT:
1576 case VK_FORMAT_R16G16B16A16_UNORM:
1577 case VK_FORMAT_R16G16B16A16_SNORM:
1578 case VK_FORMAT_R16G16B16A16_USCALED:
1579 case VK_FORMAT_R16G16B16A16_SSCALED:
1580 case VK_FORMAT_R16G16B16A16_UINT:
1581 case VK_FORMAT_R16G16B16A16_SINT:
1582 case VK_FORMAT_R16G16B16A16_SFLOAT:
1583 case VK_FORMAT_R32_UINT:
1584 case VK_FORMAT_R32_SINT:
1585 case VK_FORMAT_R32_SFLOAT:
1586 case VK_FORMAT_R32G32_UINT:
1587 case VK_FORMAT_R32G32_SINT:
1588 case VK_FORMAT_R32G32_SFLOAT:
1589 case VK_FORMAT_R32G32B32_UINT:
1590 case VK_FORMAT_R32G32B32_SINT:
1591 case VK_FORMAT_R32G32B32_SFLOAT:
1592 case VK_FORMAT_R32G32B32A32_UINT:
1593 case VK_FORMAT_R32G32B32A32_SINT:
1594 case VK_FORMAT_R32G32B32A32_SFLOAT:
1595 pFormatProperties->bufferFeatures |=
1596 VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT;
1597 break;
1598 default:
1599 break;
1600 }
1601
1602 switch(format)
1603 {
1604 // Vulkan 1.1 mandatory
1605 case VK_FORMAT_R8_UNORM:
1606 case VK_FORMAT_R8_SNORM:
1607 case VK_FORMAT_R8_UINT:
1608 case VK_FORMAT_R8_SINT:
1609 case VK_FORMAT_R8G8_UNORM:
1610 case VK_FORMAT_R8G8_SNORM:
1611 case VK_FORMAT_R8G8_UINT:
1612 case VK_FORMAT_R8G8_SINT:
1613 case VK_FORMAT_R8G8B8A8_UNORM:
1614 case VK_FORMAT_R8G8B8A8_SNORM:
1615 case VK_FORMAT_R8G8B8A8_UINT:
1616 case VK_FORMAT_R8G8B8A8_SINT:
1617 case VK_FORMAT_B8G8R8A8_UNORM:
1618 case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
1619 case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
1620 case VK_FORMAT_A8B8G8R8_UINT_PACK32:
1621 case VK_FORMAT_A8B8G8R8_SINT_PACK32:
1622 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
1623 case VK_FORMAT_A2B10G10R10_UINT_PACK32:
1624 case VK_FORMAT_R16_UINT:
1625 case VK_FORMAT_R16_SINT:
1626 case VK_FORMAT_R16_SFLOAT:
1627 case VK_FORMAT_R16G16_UINT:
1628 case VK_FORMAT_R16G16_SINT:
1629 case VK_FORMAT_R16G16_SFLOAT:
1630 case VK_FORMAT_R16G16B16A16_UINT:
1631 case VK_FORMAT_R16G16B16A16_SINT:
1632 case VK_FORMAT_R16G16B16A16_SFLOAT:
1633 case VK_FORMAT_R32_UINT:
1634 case VK_FORMAT_R32_SINT:
1635 case VK_FORMAT_R32_SFLOAT:
1636 case VK_FORMAT_R32G32_UINT:
1637 case VK_FORMAT_R32G32_SINT:
1638 case VK_FORMAT_R32G32_SFLOAT:
1639 case VK_FORMAT_R32G32B32A32_UINT:
1640 case VK_FORMAT_R32G32B32A32_SINT:
1641 case VK_FORMAT_R32G32B32A32_SFLOAT:
1642 case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
1643 // Optional
1644 case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
1645 case VK_FORMAT_A2R10G10B10_UINT_PACK32:
1646 pFormatProperties->bufferFeatures |=
1647 VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT;
1648 break;
1649 default:
1650 break;
1651 }
1652
1653 if(pFormatProperties->optimalTilingFeatures)
1654 {
1655 pFormatProperties->linearTilingFeatures = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
1656 VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
1657
1658 if(!format.isCompressed())
1659 {
1660 if(pFormatProperties->optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)
1661 {
1662 pFormatProperties->linearTilingFeatures |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
1663 }
1664 if(pFormatProperties->optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT)
1665 {
1666 pFormatProperties->linearTilingFeatures |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
1667 }
1668 }
1669 }
1670 }
1671
getImageFormatProperties(Format format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties) const1672 void PhysicalDevice::getImageFormatProperties(Format format, VkImageType type, VkImageTiling tiling,
1673 VkImageUsageFlags usage, VkImageCreateFlags flags,
1674 VkImageFormatProperties *pImageFormatProperties) const
1675 {
1676 pImageFormatProperties->sampleCounts = VK_SAMPLE_COUNT_1_BIT;
1677 pImageFormatProperties->maxArrayLayers = vk::MAX_IMAGE_ARRAY_LAYERS;
1678 pImageFormatProperties->maxExtent.depth = 1;
1679
1680 switch(type)
1681 {
1682 case VK_IMAGE_TYPE_1D:
1683 pImageFormatProperties->maxMipLevels = vk::MAX_IMAGE_LEVELS_1D;
1684 pImageFormatProperties->maxExtent.width = 1 << (vk::MAX_IMAGE_LEVELS_1D - 1);
1685 pImageFormatProperties->maxExtent.height = 1;
1686 break;
1687 case VK_IMAGE_TYPE_2D:
1688 if(flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)
1689 {
1690 pImageFormatProperties->maxMipLevels = vk::MAX_IMAGE_LEVELS_CUBE;
1691 pImageFormatProperties->maxExtent.width = 1 << (vk::MAX_IMAGE_LEVELS_CUBE - 1);
1692 pImageFormatProperties->maxExtent.height = 1 << (vk::MAX_IMAGE_LEVELS_CUBE - 1);
1693 }
1694 else
1695 {
1696 pImageFormatProperties->maxMipLevels = vk::MAX_IMAGE_LEVELS_2D;
1697 pImageFormatProperties->maxExtent.width = 1 << (vk::MAX_IMAGE_LEVELS_2D - 1);
1698 pImageFormatProperties->maxExtent.height = 1 << (vk::MAX_IMAGE_LEVELS_2D - 1);
1699
1700 VkFormatProperties props;
1701 GetFormatProperties(format, &props);
1702 auto features = tiling == VK_IMAGE_TILING_LINEAR ? props.linearTilingFeatures : props.optimalTilingFeatures;
1703 if(features & (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT))
1704 {
1705 // Only renderable formats make sense for multisample
1706 pImageFormatProperties->sampleCounts = getSampleCounts();
1707 }
1708 }
1709 break;
1710 case VK_IMAGE_TYPE_3D:
1711 pImageFormatProperties->maxMipLevels = vk::MAX_IMAGE_LEVELS_3D;
1712 pImageFormatProperties->maxExtent.width = 1 << (vk::MAX_IMAGE_LEVELS_3D - 1);
1713 pImageFormatProperties->maxExtent.height = 1 << (vk::MAX_IMAGE_LEVELS_3D - 1);
1714 pImageFormatProperties->maxExtent.depth = 1 << (vk::MAX_IMAGE_LEVELS_3D - 1);
1715 pImageFormatProperties->maxArrayLayers = 1; // no 3D + layers
1716 break;
1717 default:
1718 UNREACHABLE("VkImageType: %d", int(type));
1719 break;
1720 }
1721
1722 pImageFormatProperties->maxResourceSize = 1u << 31; // Minimum value for maxResourceSize
1723
1724 // "Images created with tiling equal to VK_IMAGE_TILING_LINEAR have further restrictions on their limits and capabilities
1725 // compared to images created with tiling equal to VK_IMAGE_TILING_OPTIMAL."
1726 if(tiling == VK_IMAGE_TILING_LINEAR)
1727 {
1728 pImageFormatProperties->maxMipLevels = 1;
1729 pImageFormatProperties->maxArrayLayers = 1;
1730 pImageFormatProperties->sampleCounts = VK_SAMPLE_COUNT_1_BIT;
1731 }
1732
1733 // "Images created with a format from one of those listed in Formats requiring sampler Y'CbCr conversion for VK_IMAGE_ASPECT_COLOR_BIT image views
1734 // have further restrictions on their limits and capabilities compared to images created with other formats."
1735 if(format.isYcbcrFormat())
1736 {
1737 pImageFormatProperties->maxMipLevels = 1; // TODO(b/151263485): This is relied on by the sampler to disable mipmapping for Y'CbCr image sampling.
1738 pImageFormatProperties->maxArrayLayers = 1;
1739 pImageFormatProperties->sampleCounts = VK_SAMPLE_COUNT_1_BIT;
1740 }
1741 }
1742
getQueueFamilyPropertyCount() const1743 uint32_t PhysicalDevice::getQueueFamilyPropertyCount() const
1744 {
1745 return 1;
1746 }
1747
getQueueFamilyProperties() const1748 VkQueueFamilyProperties PhysicalDevice::getQueueFamilyProperties() const
1749 {
1750 VkQueueFamilyProperties properties = {};
1751 properties.minImageTransferGranularity.width = 1;
1752 properties.minImageTransferGranularity.height = 1;
1753 properties.minImageTransferGranularity.depth = 1;
1754 properties.queueCount = 1;
1755 properties.queueFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT;
1756 properties.timestampValidBits = 64;
1757
1758 return properties;
1759 }
1760
getQueueFamilyProperties(uint32_t pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties) const1761 void PhysicalDevice::getQueueFamilyProperties(uint32_t pQueueFamilyPropertyCount,
1762 VkQueueFamilyProperties *pQueueFamilyProperties) const
1763 {
1764 for(uint32_t i = 0; i < pQueueFamilyPropertyCount; i++)
1765 {
1766 pQueueFamilyProperties[i] = getQueueFamilyProperties();
1767 }
1768 }
1769
getQueueFamilyProperties(uint32_t pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties) const1770 void PhysicalDevice::getQueueFamilyProperties(uint32_t pQueueFamilyPropertyCount,
1771 VkQueueFamilyProperties2 *pQueueFamilyProperties) const
1772 {
1773 for(uint32_t i = 0; i < pQueueFamilyPropertyCount; i++)
1774 {
1775 pQueueFamilyProperties[i].queueFamilyProperties = getQueueFamilyProperties();
1776 }
1777 }
1778
GetMemoryProperties()1779 const VkPhysicalDeviceMemoryProperties &PhysicalDevice::GetMemoryProperties()
1780 {
1781 static const VkPhysicalDeviceMemoryProperties properties{
1782 1, // memoryTypeCount
1783 {
1784 // vk::MEMORY_TYPE_GENERIC_BIT
1785 {
1786 (VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
1787 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
1788 VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
1789 VK_MEMORY_PROPERTY_HOST_CACHED_BIT), // propertyFlags
1790 0 // heapIndex
1791 },
1792 },
1793 1, // memoryHeapCount
1794 {
1795 {
1796 vk::PHYSICAL_DEVICE_HEAP_SIZE, // size
1797 VK_MEMORY_HEAP_DEVICE_LOCAL_BIT // flags
1798 },
1799 }
1800 };
1801
1802 return properties;
1803 }
1804
1805 } // namespace vk
1806