suwako / ShaderPlayground

master
ブランチ master
ShaderPlayground / deps / glfw / src / vulkan.c
11.5 KB、332行 生 Blame 履歴
1//========================================================================
2// GLFW 3.3 - www.glfw.org
3//------------------------------------------------------------------------
4// Copyright (c) 2002-2006 Marcus Geelnard
5// Copyright (c) 2006-2018 Camilla Löwy <elmindreda@glfw.org>
6//
7// This software is provided 'as-is', without any express or implied
8// warranty. In no event will the authors be held liable for any damages
9// arising from the use of this software.
10//
11// Permission is granted to anyone to use this software for any purpose,
12// including commercial applications, and to alter it and redistribute it
13// freely, subject to the following restrictions:
14//
15// 1. The origin of this software must not be misrepresented; you must not
16// claim that you wrote the original software. If you use this software
17// in a product, an acknowledgment in the product documentation would
18// be appreciated but is not required.
19//
20// 2. Altered source versions must be plainly marked as such, and must not
21// be misrepresented as being the original software.
22//
23// 3. This notice may not be removed or altered from any source
24// distribution.
25//
26//========================================================================
27// Please use C89 style variable declarations in this file because VS 2010
28//========================================================================
29
30#include "internal.h"
31
32#include <assert.h>
33#include <string.h>
34#include <stdlib.h>
35
36#define _GLFW_FIND_LOADER 1
37#define _GLFW_REQUIRE_LOADER 2
38
39
40//////////////////////////////////////////////////////////////////////////
41////// GLFW internal API //////
42//////////////////////////////////////////////////////////////////////////
43
44GLFWbool _glfwInitVulkan(int mode)
45{
46 VkResult err;
47 VkExtensionProperties* ep;
48 uint32_t i, count;
49
50 if (_glfw.vk.available)
51 return GLFW_TRUE;
52
53#if !defined(_GLFW_VULKAN_STATIC)
54#if defined(_GLFW_VULKAN_LIBRARY)
55 _glfw.vk.handle = _glfw_dlopen(_GLFW_VULKAN_LIBRARY);
56#elif defined(_GLFW_WIN32)
57 _glfw.vk.handle = _glfw_dlopen("vulkan-1.dll");
58#elif defined(_GLFW_COCOA)
59 _glfw.vk.handle = _glfw_dlopen("libvulkan.1.dylib");
60 if (!_glfw.vk.handle)
61 _glfw.vk.handle = _glfwLoadLocalVulkanLoaderNS();
62#else
63 _glfw.vk.handle = _glfw_dlopen("libvulkan.so.1");
64#endif
65 if (!_glfw.vk.handle)
66 {
67 if (mode == _GLFW_REQUIRE_LOADER)
68 _glfwInputError(GLFW_API_UNAVAILABLE, "Vulkan: Loader not found");
69
70 return GLFW_FALSE;
71 }
72
73 _glfw.vk.GetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)
74 _glfw_dlsym(_glfw.vk.handle, "vkGetInstanceProcAddr");
75 if (!_glfw.vk.GetInstanceProcAddr)
76 {
77 _glfwInputError(GLFW_API_UNAVAILABLE,
78 "Vulkan: Loader does not export vkGetInstanceProcAddr");
79
80 _glfwTerminateVulkan();
81 return GLFW_FALSE;
82 }
83
84 _glfw.vk.EnumerateInstanceExtensionProperties = (PFN_vkEnumerateInstanceExtensionProperties)
85 vkGetInstanceProcAddr(NULL, "vkEnumerateInstanceExtensionProperties");
86 if (!_glfw.vk.EnumerateInstanceExtensionProperties)
87 {
88 _glfwInputError(GLFW_API_UNAVAILABLE,
89 "Vulkan: Failed to retrieve vkEnumerateInstanceExtensionProperties");
90
91 _glfwTerminateVulkan();
92 return GLFW_FALSE;
93 }
94#endif // _GLFW_VULKAN_STATIC
95
96 err = vkEnumerateInstanceExtensionProperties(NULL, &count, NULL);
97 if (err)
98 {
99 // NOTE: This happens on systems with a loader but without any Vulkan ICD
100 if (mode == _GLFW_REQUIRE_LOADER)
101 {
102 _glfwInputError(GLFW_API_UNAVAILABLE,
103 "Vulkan: Failed to query instance extension count: %s",
104 _glfwGetVulkanResultString(err));
105 }
106
107 _glfwTerminateVulkan();
108 return GLFW_FALSE;
109 }
110
111 ep = calloc(count, sizeof(VkExtensionProperties));
112
113 err = vkEnumerateInstanceExtensionProperties(NULL, &count, ep);
114 if (err)
115 {
116 _glfwInputError(GLFW_API_UNAVAILABLE,
117 "Vulkan: Failed to query instance extensions: %s",
118 _glfwGetVulkanResultString(err));
119
120 free(ep);
121 _glfwTerminateVulkan();
122 return GLFW_FALSE;
123 }
124
125 for (i = 0; i < count; i++)
126 {
127 if (strcmp(ep[i].extensionName, "VK_KHR_surface") == 0)
128 _glfw.vk.KHR_surface = GLFW_TRUE;
129#if defined(_GLFW_WIN32)
130 else if (strcmp(ep[i].extensionName, "VK_KHR_win32_surface") == 0)
131 _glfw.vk.KHR_win32_surface = GLFW_TRUE;
132#elif defined(_GLFW_COCOA)
133 else if (strcmp(ep[i].extensionName, "VK_MVK_macos_surface") == 0)
134 _glfw.vk.MVK_macos_surface = GLFW_TRUE;
135 else if (strcmp(ep[i].extensionName, "VK_EXT_metal_surface") == 0)
136 _glfw.vk.EXT_metal_surface = GLFW_TRUE;
137#elif defined(_GLFW_X11)
138 else if (strcmp(ep[i].extensionName, "VK_KHR_xlib_surface") == 0)
139 _glfw.vk.KHR_xlib_surface = GLFW_TRUE;
140 else if (strcmp(ep[i].extensionName, "VK_KHR_xcb_surface") == 0)
141 _glfw.vk.KHR_xcb_surface = GLFW_TRUE;
142#elif defined(_GLFW_WAYLAND)
143 else if (strcmp(ep[i].extensionName, "VK_KHR_wayland_surface") == 0)
144 _glfw.vk.KHR_wayland_surface = GLFW_TRUE;
145#endif
146 }
147
148 free(ep);
149
150 _glfw.vk.available = GLFW_TRUE;
151
152 _glfwPlatformGetRequiredInstanceExtensions(_glfw.vk.extensions);
153
154 return GLFW_TRUE;
155}
156
157void _glfwTerminateVulkan(void)
158{
159#if !defined(_GLFW_VULKAN_STATIC)
160 if (_glfw.vk.handle)
161 _glfw_dlclose(_glfw.vk.handle);
162#endif
163}
164
165const char* _glfwGetVulkanResultString(VkResult result)
166{
167 switch (result)
168 {
169 case VK_SUCCESS:
170 return "Success";
171 case VK_NOT_READY:
172 return "A fence or query has not yet completed";
173 case VK_TIMEOUT:
174 return "A wait operation has not completed in the specified time";
175 case VK_EVENT_SET:
176 return "An event is signaled";
177 case VK_EVENT_RESET:
178 return "An event is unsignaled";
179 case VK_INCOMPLETE:
180 return "A return array was too small for the result";
181 case VK_ERROR_OUT_OF_HOST_MEMORY:
182 return "A host memory allocation has failed";
183 case VK_ERROR_OUT_OF_DEVICE_MEMORY:
184 return "A device memory allocation has failed";
185 case VK_ERROR_INITIALIZATION_FAILED:
186 return "Initialization of an object could not be completed for implementation-specific reasons";
187 case VK_ERROR_DEVICE_LOST:
188 return "The logical or physical device has been lost";
189 case VK_ERROR_MEMORY_MAP_FAILED:
190 return "Mapping of a memory object has failed";
191 case VK_ERROR_LAYER_NOT_PRESENT:
192 return "A requested layer is not present or could not be loaded";
193 case VK_ERROR_EXTENSION_NOT_PRESENT:
194 return "A requested extension is not supported";
195 case VK_ERROR_FEATURE_NOT_PRESENT:
196 return "A requested feature is not supported";
197 case VK_ERROR_INCOMPATIBLE_DRIVER:
198 return "The requested version of Vulkan is not supported by the driver or is otherwise incompatible";
199 case VK_ERROR_TOO_MANY_OBJECTS:
200 return "Too many objects of the type have already been created";
201 case VK_ERROR_FORMAT_NOT_SUPPORTED:
202 return "A requested format is not supported on this device";
203 case VK_ERROR_SURFACE_LOST_KHR:
204 return "A surface is no longer available";
205 case VK_SUBOPTIMAL_KHR:
206 return "A swapchain no longer matches the surface properties exactly, but can still be used";
207 case VK_ERROR_OUT_OF_DATE_KHR:
208 return "A surface has changed in such a way that it is no longer compatible with the swapchain";
209 case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR:
210 return "The display used by a swapchain does not use the same presentable image layout";
211 case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR:
212 return "The requested window is already connected to a VkSurfaceKHR, or to some other non-Vulkan API";
213 case VK_ERROR_VALIDATION_FAILED_EXT:
214 return "A validation layer found an error";
215 default:
216 return "ERROR: UNKNOWN VULKAN ERROR";
217 }
218}
219
220
221//////////////////////////////////////////////////////////////////////////
222////// GLFW public API //////
223//////////////////////////////////////////////////////////////////////////
224
225GLFWAPI int glfwVulkanSupported(void)
226{
227 _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
228 return _glfwInitVulkan(_GLFW_FIND_LOADER);
229}
230
231GLFWAPI const char** glfwGetRequiredInstanceExtensions(uint32_t* count)
232{
233 assert(count != NULL);
234
235 *count = 0;
236
237 _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
238
239 if (!_glfwInitVulkan(_GLFW_REQUIRE_LOADER))
240 return NULL;
241
242 if (!_glfw.vk.extensions[0])
243 return NULL;
244
245 *count = 2;
246 return (const char**) _glfw.vk.extensions;
247}
248
249GLFWAPI GLFWvkproc glfwGetInstanceProcAddress(VkInstance instance,
250 const char* procname)
251{
252 GLFWvkproc proc;
253 assert(procname != NULL);
254
255 _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
256
257 if (!_glfwInitVulkan(_GLFW_REQUIRE_LOADER))
258 return NULL;
259
260 proc = (GLFWvkproc) vkGetInstanceProcAddr(instance, procname);
261#if defined(_GLFW_VULKAN_STATIC)
262 if (!proc)
263 {
264 if (strcmp(procname, "vkGetInstanceProcAddr") == 0)
265 return (GLFWvkproc) vkGetInstanceProcAddr;
266 }
267#else
268 if (!proc)
269 proc = (GLFWvkproc) _glfw_dlsym(_glfw.vk.handle, procname);
270#endif
271
272 return proc;
273}
274
275GLFWAPI int glfwGetPhysicalDevicePresentationSupport(VkInstance instance,
276 VkPhysicalDevice device,
277 uint32_t queuefamily)
278{
279 assert(instance != VK_NULL_HANDLE);
280 assert(device != VK_NULL_HANDLE);
281
282 _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
283
284 if (!_glfwInitVulkan(_GLFW_REQUIRE_LOADER))
285 return GLFW_FALSE;
286
287 if (!_glfw.vk.extensions[0])
288 {
289 _glfwInputError(GLFW_API_UNAVAILABLE,
290 "Vulkan: Window surface creation extensions not found");
291 return GLFW_FALSE;
292 }
293
294 return _glfwPlatformGetPhysicalDevicePresentationSupport(instance,
295 device,
296 queuefamily);
297}
298
299GLFWAPI VkResult glfwCreateWindowSurface(VkInstance instance,
300 GLFWwindow* handle,
301 const VkAllocationCallbacks* allocator,
302 VkSurfaceKHR* surface)
303{
304 _GLFWwindow* window = (_GLFWwindow*) handle;
305 assert(instance != VK_NULL_HANDLE);
306 assert(window != NULL);
307 assert(surface != NULL);
308
309 *surface = VK_NULL_HANDLE;
310
311 _GLFW_REQUIRE_INIT_OR_RETURN(VK_ERROR_INITIALIZATION_FAILED);
312
313 if (!_glfwInitVulkan(_GLFW_REQUIRE_LOADER))
314 return VK_ERROR_INITIALIZATION_FAILED;
315
316 if (!_glfw.vk.extensions[0])
317 {
318 _glfwInputError(GLFW_API_UNAVAILABLE,
319 "Vulkan: Window surface creation extensions not found");
320 return VK_ERROR_EXTENSION_NOT_PRESENT;
321 }
322
323 if (window->context.client != GLFW_NO_API)
324 {
325 _glfwInputError(GLFW_INVALID_VALUE,
326 "Vulkan: Window surface creation requires the window to have the client API set to GLFW_NO_API");
327 return VK_ERROR_NATIVE_WINDOW_IN_USE_KHR;
328 }
329
330 return _glfwPlatformCreateWindowSurface(instance, window, allocator, surface);
331}
332