jvanverth | d2497f3 | 2016-03-18 12:39:05 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2016 Google Inc. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
| 7 | |
| 8 | #include "vk/GrVkExtensions.h" |
| 9 | #include "vk/GrVkUtil.h" |
| 10 | |
| 11 | #include "SkTSearch.h" |
| 12 | #include "SkTSort.h" |
| 13 | |
| 14 | namespace { // This cannot be static because it is used as a template parameter. |
| 15 | inline bool extension_compare(const SkString& a, const SkString& b) { |
| 16 | return strcmp(a.c_str(), b.c_str()) < 0; |
| 17 | } |
| 18 | } |
| 19 | |
| 20 | // finds the index of ext in strings or a negative result if ext is not found. |
| 21 | static int find_string(const SkTArray<SkString>& strings, const char ext[]) { |
| 22 | if (strings.empty()) { |
| 23 | return -1; |
| 24 | } |
| 25 | SkString extensionStr(ext); |
| 26 | int idx = SkTSearch<SkString, extension_compare>(&strings.front(), |
| 27 | strings.count(), |
| 28 | extensionStr, |
| 29 | sizeof(SkString)); |
| 30 | return idx; |
| 31 | } |
| 32 | |
jvanverth | fd7bd45 | 2016-03-25 06:29:52 -0700 | [diff] [blame] | 33 | #define GET_PROC_LOCAL(inst, F) PFN_vk ## F F = (PFN_vk ## F) vkGetInstanceProcAddr(inst, "vk" #F) |
jvanverth | d2497f3 | 2016-03-18 12:39:05 -0700 | [diff] [blame] | 34 | |
jvanverth | fd7bd45 | 2016-03-25 06:29:52 -0700 | [diff] [blame] | 35 | bool GrVkExtensions::initInstance(uint32_t specVersion) { |
jvanverth | d2497f3 | 2016-03-18 12:39:05 -0700 | [diff] [blame] | 36 | |
jvanverth | fd7bd45 | 2016-03-25 06:29:52 -0700 | [diff] [blame] | 37 | GET_PROC_LOCAL(nullptr, EnumerateInstanceExtensionProperties); |
| 38 | GET_PROC_LOCAL(nullptr, EnumerateInstanceLayerProperties); |
jvanverth | d2497f3 | 2016-03-18 12:39:05 -0700 | [diff] [blame] | 39 | |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 40 | SkTLessFunctionToFunctorAdaptor<SkString, extension_compare> cmp; |
jvanverth | d2497f3 | 2016-03-18 12:39:05 -0700 | [diff] [blame] | 41 | |
jvanverth | fd7bd45 | 2016-03-25 06:29:52 -0700 | [diff] [blame] | 42 | if (!EnumerateInstanceExtensionProperties || |
| 43 | !EnumerateInstanceLayerProperties) { |
jvanverth | d2497f3 | 2016-03-18 12:39:05 -0700 | [diff] [blame] | 44 | return false; |
| 45 | } |
| 46 | |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 47 | // instance layers |
| 48 | uint32_t layerCount = 0; |
jvanverth | fd7bd45 | 2016-03-25 06:29:52 -0700 | [diff] [blame] | 49 | VkResult res = EnumerateInstanceLayerProperties(&layerCount, nullptr); |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 50 | if (VK_SUCCESS != res) { |
| 51 | return false; |
| 52 | } |
| 53 | VkLayerProperties* layers = new VkLayerProperties[layerCount]; |
jvanverth | fd7bd45 | 2016-03-25 06:29:52 -0700 | [diff] [blame] | 54 | res = EnumerateInstanceLayerProperties(&layerCount, layers); |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 55 | if (VK_SUCCESS != res) { |
egdaniel | 8af936d | 2016-04-07 10:17:47 -0700 | [diff] [blame^] | 56 | delete[] layers; |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 57 | return false; |
| 58 | } |
| 59 | for (uint32_t i = 0; i < layerCount; ++i) { |
| 60 | if (specVersion >= layers[i].specVersion) { |
| 61 | fInstanceLayerStrings->push_back() = layers[i].layerName; |
| 62 | } |
| 63 | } |
| 64 | delete[] layers; |
| 65 | if (!fInstanceLayerStrings->empty()) { |
| 66 | SkTQSort(&fInstanceLayerStrings->front(), &fInstanceLayerStrings->back(), cmp); |
| 67 | } |
jvanverth | d2497f3 | 2016-03-18 12:39:05 -0700 | [diff] [blame] | 68 | |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 69 | // instance extensions |
| 70 | // via Vulkan implementation and implicitly enabled layers |
| 71 | uint32_t extensionCount = 0; |
jvanverth | fd7bd45 | 2016-03-25 06:29:52 -0700 | [diff] [blame] | 72 | res = EnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr); |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 73 | if (VK_SUCCESS != res) { |
| 74 | return false; |
| 75 | } |
jvanverth | d2497f3 | 2016-03-18 12:39:05 -0700 | [diff] [blame] | 76 | VkExtensionProperties* extensions = new VkExtensionProperties[extensionCount]; |
jvanverth | fd7bd45 | 2016-03-25 06:29:52 -0700 | [diff] [blame] | 77 | res = EnumerateInstanceExtensionProperties(nullptr, &extensionCount, extensions); |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 78 | if (VK_SUCCESS != res) { |
egdaniel | 8af936d | 2016-04-07 10:17:47 -0700 | [diff] [blame^] | 79 | delete[] extensions; |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 80 | return false; |
| 81 | } |
jvanverth | d2497f3 | 2016-03-18 12:39:05 -0700 | [diff] [blame] | 82 | for (uint32_t i = 0; i < extensionCount; ++i) { |
| 83 | if (specVersion >= extensions[i].specVersion) { |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 84 | fInstanceExtensionStrings->push_back() = extensions[i].extensionName; |
jvanverth | d2497f3 | 2016-03-18 12:39:05 -0700 | [diff] [blame] | 85 | } |
| 86 | } |
| 87 | delete [] extensions; |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 88 | // sort so we can search |
jvanverth | d2497f3 | 2016-03-18 12:39:05 -0700 | [diff] [blame] | 89 | if (!fInstanceExtensionStrings->empty()) { |
jvanverth | d2497f3 | 2016-03-18 12:39:05 -0700 | [diff] [blame] | 90 | SkTQSort(&fInstanceExtensionStrings->front(), &fInstanceExtensionStrings->back(), cmp); |
| 91 | } |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 92 | // via explicitly enabled layers |
| 93 | layerCount = fInstanceLayerStrings->count(); |
| 94 | for (uint32_t layerIndex = 0; layerIndex < layerCount; ++layerIndex) { |
| 95 | uint32_t extensionCount = 0; |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 96 | res = EnumerateInstanceExtensionProperties((*fInstanceLayerStrings)[layerIndex].c_str(), |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 97 | &extensionCount, nullptr); |
| 98 | if (VK_SUCCESS != res) { |
| 99 | return false; |
| 100 | } |
| 101 | VkExtensionProperties* extensions = new VkExtensionProperties[extensionCount]; |
jvanverth | fd7bd45 | 2016-03-25 06:29:52 -0700 | [diff] [blame] | 102 | res = EnumerateInstanceExtensionProperties((*fInstanceLayerStrings)[layerIndex].c_str(), |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 103 | &extensionCount, extensions); |
| 104 | if (VK_SUCCESS != res) { |
egdaniel | 8af936d | 2016-04-07 10:17:47 -0700 | [diff] [blame^] | 105 | delete[] extensions; |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 106 | return false; |
| 107 | } |
| 108 | for (uint32_t i = 0; i < extensionCount; ++i) { |
| 109 | // if not already in the list, add it |
| 110 | if (specVersion >= extensions[i].specVersion && |
| 111 | find_string(*fInstanceExtensionStrings, extensions[i].extensionName) < 0) { |
| 112 | fInstanceExtensionStrings->push_back() = extensions[i].extensionName; |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 113 | SkTQSort(&fInstanceExtensionStrings->front(), &fInstanceExtensionStrings->back(), |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 114 | cmp); |
| 115 | } |
| 116 | } |
| 117 | delete[] extensions; |
| 118 | } |
| 119 | |
jvanverth | fd7bd45 | 2016-03-25 06:29:52 -0700 | [diff] [blame] | 120 | return true; |
| 121 | } |
| 122 | |
| 123 | bool GrVkExtensions::initDevice(uint32_t specVersion, VkInstance inst, VkPhysicalDevice physDev) { |
| 124 | |
| 125 | GET_PROC_LOCAL(inst, EnumerateDeviceExtensionProperties); |
| 126 | GET_PROC_LOCAL(inst, EnumerateDeviceLayerProperties); |
| 127 | |
| 128 | SkTLessFunctionToFunctorAdaptor<SkString, extension_compare> cmp; |
| 129 | |
| 130 | if (!EnumerateDeviceExtensionProperties || |
| 131 | !EnumerateDeviceLayerProperties) { |
| 132 | return false; |
| 133 | } |
| 134 | |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 135 | // device layers |
jvanverth | fd7bd45 | 2016-03-25 06:29:52 -0700 | [diff] [blame] | 136 | uint32_t layerCount = 0; |
| 137 | VkResult res = EnumerateDeviceLayerProperties(physDev, &layerCount, nullptr); |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 138 | if (VK_SUCCESS != res) { |
| 139 | return false; |
| 140 | } |
jvanverth | fd7bd45 | 2016-03-25 06:29:52 -0700 | [diff] [blame] | 141 | VkLayerProperties* layers = new VkLayerProperties[layerCount]; |
| 142 | res = EnumerateDeviceLayerProperties(physDev, &layerCount, layers); |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 143 | if (VK_SUCCESS != res) { |
egdaniel | 8af936d | 2016-04-07 10:17:47 -0700 | [diff] [blame^] | 144 | delete[] layers; |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 145 | return false; |
| 146 | } |
| 147 | for (uint32_t i = 0; i < layerCount; ++i) { |
| 148 | if (specVersion >= layers[i].specVersion) { |
| 149 | fDeviceLayerStrings->push_back() = layers[i].layerName; |
| 150 | } |
| 151 | } |
| 152 | delete[] layers; |
| 153 | if (!fDeviceLayerStrings->empty()) { |
| 154 | SkTLessFunctionToFunctorAdaptor<SkString, extension_compare> cmp; |
| 155 | SkTQSort(&fDeviceLayerStrings->front(), &fDeviceLayerStrings->back(), cmp); |
| 156 | } |
| 157 | |
| 158 | // device extensions |
| 159 | // via Vulkan implementation and implicitly enabled layers |
jvanverth | fd7bd45 | 2016-03-25 06:29:52 -0700 | [diff] [blame] | 160 | uint32_t extensionCount = 0; |
| 161 | res = EnumerateDeviceExtensionProperties(physDev, nullptr, &extensionCount, nullptr); |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 162 | if (VK_SUCCESS != res) { |
| 163 | return false; |
| 164 | } |
jvanverth | fd7bd45 | 2016-03-25 06:29:52 -0700 | [diff] [blame] | 165 | VkExtensionProperties* extensions = new VkExtensionProperties[extensionCount]; |
| 166 | res = EnumerateDeviceExtensionProperties(physDev, nullptr, &extensionCount, extensions); |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 167 | if (VK_SUCCESS != res) { |
egdaniel | 8af936d | 2016-04-07 10:17:47 -0700 | [diff] [blame^] | 168 | delete[] extensions; |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 169 | return false; |
| 170 | } |
| 171 | for (uint32_t i = 0; i < extensionCount; ++i) { |
| 172 | if (specVersion >= extensions[i].specVersion) { |
| 173 | fDeviceExtensionStrings->push_back() = extensions[i].extensionName; |
| 174 | } |
| 175 | } |
| 176 | delete[] extensions; |
| 177 | if (!fDeviceExtensionStrings->empty()) { |
| 178 | SkTLessFunctionToFunctorAdaptor<SkString, extension_compare> cmp; |
| 179 | SkTQSort(&fDeviceExtensionStrings->front(), &fDeviceExtensionStrings->back(), cmp); |
| 180 | } |
| 181 | // via explicitly enabled layers |
| 182 | layerCount = fDeviceLayerStrings->count(); |
| 183 | for (uint32_t layerIndex = 0; layerIndex < layerCount; ++layerIndex) { |
| 184 | uint32_t extensionCount = 0; |
jvanverth | fd7bd45 | 2016-03-25 06:29:52 -0700 | [diff] [blame] | 185 | res = EnumerateDeviceExtensionProperties(physDev, |
| 186 | (*fDeviceLayerStrings)[layerIndex].c_str(), |
| 187 | &extensionCount, nullptr); |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 188 | if (VK_SUCCESS != res) { |
| 189 | return false; |
| 190 | } |
| 191 | VkExtensionProperties* extensions = new VkExtensionProperties[extensionCount]; |
jvanverth | fd7bd45 | 2016-03-25 06:29:52 -0700 | [diff] [blame] | 192 | res = EnumerateDeviceExtensionProperties(physDev, |
| 193 | (*fDeviceLayerStrings)[layerIndex].c_str(), |
| 194 | &extensionCount, extensions); |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 195 | if (VK_SUCCESS != res) { |
egdaniel | 8af936d | 2016-04-07 10:17:47 -0700 | [diff] [blame^] | 196 | delete[] extensions; |
jvanverth | 633b356 | 2016-03-23 11:01:22 -0700 | [diff] [blame] | 197 | return false; |
| 198 | } |
| 199 | for (uint32_t i = 0; i < extensionCount; ++i) { |
| 200 | // if not already in the list, add it |
| 201 | if (specVersion >= extensions[i].specVersion && |
| 202 | find_string(*fDeviceExtensionStrings, extensions[i].extensionName) < 0) { |
| 203 | fDeviceExtensionStrings->push_back() = extensions[i].extensionName; |
| 204 | SkTQSort(&fDeviceExtensionStrings->front(), &fDeviceExtensionStrings->back(), cmp); |
| 205 | } |
| 206 | } |
| 207 | delete[] extensions; |
| 208 | } |
jvanverth | d2497f3 | 2016-03-18 12:39:05 -0700 | [diff] [blame] | 209 | |
jvanverth | d2497f3 | 2016-03-18 12:39:05 -0700 | [diff] [blame] | 210 | return true; |
| 211 | } |
| 212 | |
jvanverth | d2497f3 | 2016-03-18 12:39:05 -0700 | [diff] [blame] | 213 | bool GrVkExtensions::hasInstanceExtension(const char ext[]) const { |
jvanverth | d2497f3 | 2016-03-18 12:39:05 -0700 | [diff] [blame] | 214 | return find_string(*fInstanceExtensionStrings, ext) >= 0; |
| 215 | } |
| 216 | |
| 217 | bool GrVkExtensions::hasDeviceExtension(const char ext[]) const { |
jvanverth | d2497f3 | 2016-03-18 12:39:05 -0700 | [diff] [blame] | 218 | return find_string(*fDeviceExtensionStrings, ext) >= 0; |
| 219 | } |
| 220 | |
| 221 | bool GrVkExtensions::hasInstanceLayer(const char ext[]) const { |
jvanverth | d2497f3 | 2016-03-18 12:39:05 -0700 | [diff] [blame] | 222 | return find_string(*fInstanceLayerStrings, ext) >= 0; |
| 223 | } |
| 224 | |
| 225 | bool GrVkExtensions::hasDeviceLayer(const char ext[]) const { |
jvanverth | d2497f3 | 2016-03-18 12:39:05 -0700 | [diff] [blame] | 226 | return find_string(*fDeviceLayerStrings, ext) >= 0; |
| 227 | } |
| 228 | |
jvanverth | d2497f3 | 2016-03-18 12:39:05 -0700 | [diff] [blame] | 229 | void GrVkExtensions::print(const char* sep) const { |
| 230 | if (nullptr == sep) { |
| 231 | sep = " "; |
| 232 | } |
| 233 | int cnt = fInstanceExtensionStrings->count(); |
| 234 | SkDebugf("Instance Extensions: "); |
| 235 | for (int i = 0; i < cnt; ++i) { |
| 236 | SkDebugf("%s%s", (*fInstanceExtensionStrings)[i].c_str(), (i < cnt - 1) ? sep : ""); |
| 237 | } |
| 238 | cnt = fDeviceExtensionStrings->count(); |
| 239 | SkDebugf("\nDevice Extensions: "); |
| 240 | for (int i = 0; i < cnt; ++i) { |
| 241 | SkDebugf("%s%s", (*fDeviceExtensionStrings)[i].c_str(), (i < cnt - 1) ? sep : ""); |
| 242 | } |
| 243 | cnt = fInstanceLayerStrings->count(); |
| 244 | SkDebugf("\nInstance Layers: "); |
| 245 | for (int i = 0; i < cnt; ++i) { |
| 246 | SkDebugf("%s%s", (*fInstanceLayerStrings)[i].c_str(), (i < cnt - 1) ? sep : ""); |
| 247 | } |
| 248 | cnt = fDeviceLayerStrings->count(); |
| 249 | SkDebugf("\nDevice Layers: "); |
| 250 | for (int i = 0; i < cnt; ++i) { |
| 251 | SkDebugf("%s%s", (*fDeviceLayerStrings)[i].c_str(), (i < cnt - 1) ? sep : ""); |
| 252 | } |
| 253 | } |