OLD | NEW |
---|---|
(Empty) | |
1 // Copyright (c) 2016 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "gpu/vulkan/vulkan_implementation.h" | |
6 | |
7 #include <string> | |
8 #include <vector> | |
9 #include <vulkan/vulkan.h> | |
10 | |
11 #include "base/macros.h" | |
12 | |
13 #if defined(VK_USE_PLATFORM_XLIB_KHR) | |
14 #include "ui/gfx/x/x11_types.h" | |
15 #endif // defined(VK_USE_PLATFORM_XLIB_KHR) | |
16 | |
17 // The following code is not going to be necessary once the loader handles | |
18 // the VK_KHR_XLIB_SURFACE_EXTENSION_NAME extension. | |
19 #if defined(VK_USE_PLATFORM_XLIB_KHR) | |
20 struct VulkanProcs { | |
21 PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR | |
22 vkGetPhysicalDeviceXlibPresentationSupportKHRFn = nullptr; | |
23 | |
24 PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHRFn = nullptr; | |
25 | |
26 bool InitializeFunctions(VkInstance vk_instance) { | |
27 vkGetPhysicalDeviceXlibPresentationSupportKHRFn = | |
28 reinterpret_cast<PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR>( | |
29 vkGetInstanceProcAddr( | |
30 vk_instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR")); | |
31 | |
32 vkCreateXlibSurfaceKHRFn = reinterpret_cast<PFN_vkCreateXlibSurfaceKHR>( | |
33 vkGetInstanceProcAddr(vk_instance, "vkCreateXlibSurfaceKHR")); | |
34 | |
35 return true; | |
36 } | |
37 }; | |
38 | |
39 static VulkanProcs vulkan_procs; | |
piman
2016/03/04 21:07:09
non-POD globals are not allowed (causes global ini
David Yen
2016/03/04 22:12:28
I thought I would be able to get around the loader
piman
2016/03/05 00:11:25
vkGetInstanceProcAddr /could/ give you a more spe
David Yen
2016/03/07 23:33:31
So after building the loader locally, there are 2
| |
40 | |
41 VKAPI_ATTR VkResult VKAPI_CALL | |
42 vkCreateXlibSurfaceKHR(VkInstance instance, | |
43 const VkXlibSurfaceCreateInfoKHR* pCreateInfo, | |
44 const VkAllocationCallbacks* pAllocator, | |
45 VkSurfaceKHR* pSurface) { | |
46 return vulkan_procs.vkCreateXlibSurfaceKHRFn(instance, pCreateInfo, | |
47 pAllocator, pSurface); | |
48 } | |
49 | |
50 VKAPI_ATTR VkBool32 VKAPI_CALL | |
51 vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, | |
52 uint32_t queueFamilyIndex, | |
53 Display* dpy, | |
54 VisualID visualID) { | |
55 // TODO(dyen): Re-enable this function once drivers properly support this. | |
56 return true; | |
57 return vulkan_procs.vkGetPhysicalDeviceXlibPresentationSupportKHRFn( | |
58 physicalDevice, queueFamilyIndex, dpy, visualID); | |
59 } | |
60 | |
61 #endif // defined(VK_USE_PLATFORM_XLIB_KHR) | |
62 // End of temporary VK_KHR_XLIB_SURFACE_EXTENSION_NAME loader code. | |
63 | |
64 namespace gfx { | |
65 | |
66 struct VulkanInstance { | |
67 VulkanInstance() : valid(false) {} | |
68 | |
69 void Initialize() { | |
70 valid = InitializeVulkanInstance() && InitializeVulkanDevice(); | |
71 } | |
72 | |
73 bool InitializeVulkanInstance() { | |
74 VkResult status = VK_SUCCESS; | |
75 | |
76 VkApplicationInfo app_info = {}; | |
77 app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; | |
78 app_info.pApplicationName = "Chromium"; | |
79 app_info.apiVersion = VK_MAKE_VERSION(1, 0, 2); | |
80 | |
81 const char* instance_extensions[] = { | |
82 VK_KHR_SURFACE_EXTENSION_NAME, | |
83 | |
84 #if defined(VK_USE_PLATFORM_XLIB_KHR) | |
85 VK_KHR_XLIB_SURFACE_EXTENSION_NAME, | |
86 #endif // defined(VK_USE_PLATFORM_XLIB_KHR) | |
87 }; | |
88 | |
89 VkInstanceCreateInfo instance_create_info = {}; | |
90 instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; | |
91 instance_create_info.pApplicationInfo = &app_info; | |
92 instance_create_info.ppEnabledExtensionNames = instance_extensions; | |
93 instance_create_info.enabledExtensionCount = arraysize(instance_extensions); | |
94 | |
95 status = vkCreateInstance(&instance_create_info, nullptr, &vk_instance); | |
96 DCHECK_EQ(VK_SUCCESS, status); | |
97 if (VK_SUCCESS != status) | |
98 return false; | |
99 | |
100 // TODO(dyen): Remove once loader properly supports xlib functions. | |
101 if (!vulkan_procs.InitializeFunctions(vk_instance)) | |
102 return false; | |
103 | |
104 return true; | |
105 } | |
106 | |
107 bool InitializeVulkanDevice() { | |
108 VkResult status = VK_SUCCESS; | |
109 | |
110 uint32_t device_count = 0; | |
111 status = vkEnumeratePhysicalDevices(vk_instance, &device_count, nullptr); | |
112 if (VK_SUCCESS != status || device_count == 0) | |
113 return false; | |
114 | |
115 std::vector<VkPhysicalDevice> devices(device_count); | |
116 status = | |
117 vkEnumeratePhysicalDevices(vk_instance, &device_count, devices.data()); | |
118 if (VK_SUCCESS != status) { | |
119 LOG(ERROR) << "vkEnumeratePhysicalDevices failed: " << status; | |
120 return false; | |
121 } | |
122 | |
123 #if defined(VK_USE_PLATFORM_XLIB_KHR) | |
124 Display* xdisplay = gfx::GetXDisplay(); | |
125 VisualID visual_id = | |
126 XVisualIDFromVisual(DefaultVisual(xdisplay, DefaultScreen(xdisplay))); | |
127 #endif // defined(VK_USE_PLATFORM_XLIB_KHR) | |
128 | |
129 int device_index = -1; | |
130 int queue_index = -1; | |
131 for (size_t i = 0; i < devices.size(); ++i) { | |
132 const VkPhysicalDevice& device = devices[i]; | |
133 uint32_t queue_count = 0; | |
134 vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_count, nullptr); | |
135 if (queue_count) { | |
136 std::vector<VkQueueFamilyProperties> queue_properties(queue_count); | |
137 vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_count, | |
138 queue_properties.data()); | |
139 for (size_t n = 0; n < queue_properties.size(); ++n) { | |
140 if ((queue_properties[n].queueFlags & VK_QUEUE_GRAPHICS_BIT) == 0) | |
141 continue; | |
142 | |
143 #if defined(VK_USE_PLATFORM_XLIB_KHR) | |
144 if (!vkGetPhysicalDeviceXlibPresentationSupportKHR( | |
145 device, n, xdisplay, visual_id)) { | |
146 continue; | |
147 } | |
148 #else | |
149 #error Non-Supported Vulkan implementation. | |
150 #endif | |
151 | |
152 queue_index = static_cast<int>(n); | |
153 break; | |
154 } | |
155 | |
156 if (-1 != queue_index) { | |
157 device_index = static_cast<int>(i); | |
158 break; | |
159 } | |
160 } | |
161 } | |
162 | |
163 if (queue_index == -1) | |
164 return false; | |
165 | |
166 float queue_priority = 0.0f; | |
167 VkDeviceQueueCreateInfo queue_create_info = {}; | |
168 queue_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; | |
169 queue_create_info.queueFamilyIndex = queue_index; | |
170 queue_create_info.queueCount = 1; | |
171 queue_create_info.pQueuePriorities = &queue_priority; | |
172 | |
173 const char* device_extensions[] = {VK_KHR_SWAPCHAIN_EXTENSION_NAME}; | |
174 | |
175 VkDeviceCreateInfo device_create_info = {}; | |
176 device_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; | |
177 device_create_info.queueCreateInfoCount = 1; | |
178 device_create_info.pQueueCreateInfos = &queue_create_info; | |
179 device_create_info.enabledExtensionCount = arraysize(device_extensions); | |
180 device_create_info.ppEnabledExtensionNames = device_extensions; | |
181 | |
182 status = vkCreateDevice(devices[device_index], &device_create_info, nullptr, | |
183 &vk_device); | |
184 if (VK_SUCCESS != status) | |
185 return false; | |
186 | |
187 vkGetDeviceQueue(vk_device, queue_index, 0, &vk_queue); | |
188 | |
189 return true; | |
190 } | |
191 | |
192 bool valid; | |
193 VkInstance vk_instance; | |
194 VkDevice vk_device; | |
195 VkQueue vk_queue; | |
196 }; | |
197 | |
198 static VulkanInstance vulkan_instance; | |
piman
2016/03/04 21:07:09
Same here wrt non-POD globals.
LazyInstance seems
David Yen
2016/03/04 22:12:28
Done.
| |
199 | |
200 bool InitializeVulkan() { | |
201 vulkan_instance.Initialize(); | |
202 return vulkan_instance.valid; | |
203 } | |
204 | |
205 VkInstance GetVulkanInstance() { | |
206 DCHECK(vulkan_instance.valid); | |
207 return vulkan_instance.vk_instance; | |
208 } | |
209 | |
210 VkDevice GetVulkanDevice() { | |
211 DCHECK(vulkan_instance.valid); | |
212 return vulkan_instance.vk_device; | |
213 } | |
214 | |
215 VkQueue GetVulkanQueue() { | |
216 DCHECK(vulkan_instance.valid); | |
217 return vulkan_instance.vk_queue; | |
218 } | |
219 | |
220 } // namespace gfx | |
OLD | NEW |