source/graphics/vkxlib/vulkancontext.cpp

   1 #include <stdexcept>
   2 #include <vector>
   3 #define VK_USE_PLATFORM_XLIB_KHR
   4 #include <vulkan/vulkan.h>
   5 #include <msp/core/application.h>
   6 #include <msp/debug/debugapi.h>
   7 #include <msp/io/print.h>
   8 #include "display_private.h"
   9 #include "vulkancontext.h"
  10 #include "vulkancontext_platform.h"
  11 #include "window_private.h"
  12
  13 using namespace std;
  14
  15 namespace Msp {
  16 namespace Graphics {
  17
  18 string vulkan_error::get_error_message(unsigned code)
  19 {
  20         switch(static_cast<VkResult>(code))
  21         {
  22         case VK_SUCCESS: return "success";
  23         case VK_NOT_READY: return "not ready";
  24         case VK_TIMEOUT: return "timeout";
  25         case VK_EVENT_SET: return "event set";
  26         case VK_EVENT_RESET: return "event reset";
  27         case VK_INCOMPLETE: return "incomplete";
  28         case VK_ERROR_OUT_OF_HOST_MEMORY: return "out of host memory";
  29         case VK_ERROR_OUT_OF_DEVICE_MEMORY: return "out of device memory";
  30         case VK_ERROR_INITIALIZATION_FAILED: return "initialization failed";
  31         case VK_ERROR_DEVICE_LOST: return "device lost";
  32         case VK_ERROR_MEMORY_MAP_FAILED: return "memory map failed";
  33         case VK_ERROR_LAYER_NOT_PRESENT: return "layer not present";
  34         case VK_ERROR_EXTENSION_NOT_PRESENT: return "extension not present";
  35         case VK_ERROR_FEATURE_NOT_PRESENT: return "feature not present";
  36         case VK_ERROR_INCOMPATIBLE_DRIVER: return "incompatible driver";
  37         case VK_ERROR_TOO_MANY_OBJECTS: return "too many objects";
  38         case VK_ERROR_FORMAT_NOT_SUPPORTED: return "format not supported";
  39         case VK_ERROR_FRAGMENTED_POOL: return "fragmented pool";
  40         case VK_ERROR_UNKNOWN: return "unknown";
  41         case VK_ERROR_OUT_OF_POOL_MEMORY: return "out of pool memory";
  42         case VK_ERROR_INVALID_EXTERNAL_HANDLE: return "invalidernal handle";
  43         case VK_ERROR_FRAGMENTATION: return "fragmentation";
  44         case VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS: return "invalid opaque capture address";
  45         case VK_ERROR_SURFACE_LOST_KHR: return "surface lost";
  46         case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR: return "native window in use";
  47         case VK_SUBOPTIMAL_KHR: return "suboptimal";
  48         case VK_ERROR_OUT_OF_DATE_KHR: return "out of date";
  49         case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR: return "incompatible display";
  50         case VK_ERROR_VALIDATION_FAILED_EXT: return "validation failed";
  51         case VK_ERROR_INVALID_SHADER_NV: return "invalid shader";
  52         case VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT: return "invalid drm format modifier plane layout";
  53         case VK_ERROR_NOT_PERMITTED_EXT: return "not permitted";
  54         case VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT: return "full screen exclusive mode lost";
  55         case VK_THREAD_IDLE_KHR: return "thread idle";
  56         case VK_THREAD_DONE_KHR: return "thread done";
  57         case VK_OPERATION_DEFERRED_KHR: return "operation deferred";
  58         case VK_OPERATION_NOT_DEFERRED_KHR: return "operation not deferred";
  59         case VK_PIPELINE_COMPILE_REQUIRED_EXT: return "pipeline compile required";
  60         default: return format("VkResult(%d)", code);
  61         }
  62 }
  63
  64 VulkanOptions::VulkanOptions():
  65         enable_validation(false),
  66         enable_debug_report(false),
  67         enable_geometry_shader(false),
  68         enable_tessellation_shader(false)
  69 { }
  70
  71
  72 void VulkanContext::platform_init(const VulkanOptions &opts)
  73 {
  74         priv = new Private;
  75         VulkanFunctions &f = priv->functions;
  76
  77         try
  78         {
  79                 f.vkCreateInstance = get_function<PFN_vkCreateInstance>("vkCreateInstance");
  80
  81                 vector<const char *> layers;
  82                 if(opts.enable_validation)
  83                         layers.push_back("VK_LAYER_KHRONOS_validation");
  84
  85                 vector<const char *> extensions;
  86                 extensions.push_back("VK_KHR_surface");
  87                 extensions.push_back("VK_KHR_xlib_surface");
  88                 extensions.push_back("VK_EXT_debug_utils");
  89                 if(opts.enable_debug_report)
  90                         extensions.push_back("VK_EXT_debug_report");
  91
  92                 VkApplicationInfo app_info = { };
  93                 app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
  94                 app_info.pApplicationName = Application::get_name().c_str();
  95                 app_info.pEngineName = "MSP";
  96                 app_info.apiVersion = (1<<22)|(2<<12);
  97
  98                 VkInstanceCreateInfo instance_create_info = { };
  99                 instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
 100                 instance_create_info.pApplicationInfo = &app_info;
 101                 instance_create_info.enabledLayerCount = layers.size();
 102                 instance_create_info.ppEnabledLayerNames = layers.data();
 103                 instance_create_info.enabledExtensionCount = extensions.size();
 104                 instance_create_info.ppEnabledExtensionNames = extensions.data();
 105
 106                 VkResult result = f.vkCreateInstance(&instance_create_info, 0, &priv->instance);
 107                 if(result!=VK_SUCCESS)
 108                         throw vulkan_error(result, "vkCreateInstance");
 109
 110                 f.vkDestroyInstance = get_function<PFN_vkDestroyInstance>("vkDestroyInstance");
 111                 f.vkEnumeratePhysicalDevices = get_function<PFN_vkEnumeratePhysicalDevices>("vkEnumeratePhysicalDevices");
 112                 f.vkGetPhysicalDeviceQueueFamilyProperties = get_function<PFN_vkGetPhysicalDeviceQueueFamilyProperties>("vkGetPhysicalDeviceQueueFamilyProperties");
 113                 f.vkGetPhysicalDeviceSurfaceSupport = get_function<PFN_vkGetPhysicalDeviceSurfaceSupportKHR>("vkGetPhysicalDeviceSurfaceSupportKHR");
 114                 f.vkCreateDevice = get_function<PFN_vkCreateDevice>("vkCreateDevice");
 115                 f.vkDestroyDevice = get_function<PFN_vkDestroyDevice>("vkDestroyDevice");
 116                 f.vkGetDeviceQueue = get_function<PFN_vkGetDeviceQueue>("vkGetDeviceQueue");
 117                 f.vkCreateXlibSurface = get_function<PFN_vkCreateXlibSurfaceKHR>("vkCreateXlibSurfaceKHR");
 118                 f.vkDestroySurface = get_function<PFN_vkDestroySurfaceKHR>("vkDestroySurfaceKHR");
 119                 f.vkCreateDebugReportCallback = get_function<PFN_vkCreateDebugReportCallbackEXT>("vkCreateDebugReportCallbackEXT");
 120                 f.vkDestroyDebugReportCallback = get_function<PFN_vkDestroyDebugReportCallbackEXT>("vkDestroyDebugReportCallbackEXT");
 121
 122                 if(opts.enable_debug_report)
 123                 {
 124                         VkDebugReportCallbackCreateInfoEXT debug_report_create_info = { };
 125                         debug_report_create_info.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
 126                         debug_report_create_info.flags = VK_DEBUG_REPORT_WARNING_BIT_EXT|VK_DEBUG_REPORT_ERROR_BIT_EXT|VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT|VK_DEBUG_REPORT_INFORMATION_BIT_EXT;
 127                         debug_report_create_info.pfnCallback = &Private::debug_report_func;
 128                         debug_report_create_info.pUserData = this;
 129
 130                         result = f.vkCreateDebugReportCallback(priv->instance, &debug_report_create_info, 0, &priv->debug_report_callback);
 131                         if(result!=VK_SUCCESS)
 132                                 throw vulkan_error(result, "vkCreateDebugReportCallback");
 133                 }
 134                 else
 135                         priv->debug_report_callback = 0;
 136
 137                 VkXlibSurfaceCreateInfoKHR surface_create_info = { };
 138                 surface_create_info.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
 139                 surface_create_info.dpy = display.get_private().display;
 140                 surface_create_info.window = window.get_private().window;
 141
 142                 result = f.vkCreateXlibSurface(priv->instance, &surface_create_info, 0, &priv->surface);
 143                 if(result!=VK_SUCCESS)
 144                         throw vulkan_error(result, "vkCreateXlibSurface");
 145
 146                 unsigned n_phys_devices = 0;
 147                 result = f.vkEnumeratePhysicalDevices(priv->instance, &n_phys_devices, 0);
 148                 if(result!=VK_SUCCESS)
 149                         throw vulkan_error(result, "vkEnumeratePhysicalDevices");
 150                 else if(!n_phys_devices)
 151                         throw runtime_error("no physical device found");
 152                 vector<VkPhysicalDevice> phys_devices(n_phys_devices);
 153                 result = f.vkEnumeratePhysicalDevices(priv->instance, &n_phys_devices, &phys_devices[0]);
 154                 if(result!=VK_SUCCESS)
 155                         throw vulkan_error(result, "vkEnumeratePhysicalDevices");
 156
 157                 priv->physical_device = 0;
 158                 unsigned gfx_queue_index = 0;
 159                 for(unsigned i=0; i<n_phys_devices; ++i)
 160                 {
 161                         VkPhysicalDevice phys_device = phys_devices[i];
 162
 163                         unsigned n_queue_families = 0;
 164                         f.vkGetPhysicalDeviceQueueFamilyProperties(phys_device, &n_queue_families, 0);
 165                         vector<VkQueueFamilyProperties> queue_family_props(n_queue_families);
 166                         f.vkGetPhysicalDeviceQueueFamilyProperties(phys_device, &n_queue_families, queue_family_props.data());
 167
 168                         for(; gfx_queue_index<n_queue_families; ++gfx_queue_index)
 169                                 if((queue_family_props[gfx_queue_index].queueFlags&VK_QUEUE_GRAPHICS_BIT))
 170                                         break;
 171
 172                         if(gfx_queue_index>=n_queue_families)
 173                                 continue;
 174
 175                         VkBool32 supported = VK_FALSE;
 176                         result = f.vkGetPhysicalDeviceSurfaceSupport(phys_device, gfx_queue_index, priv->surface, &supported);
 177                         if(result!=VK_SUCCESS)
 178                                 continue;
 179
 180                         if(supported)
 181                         {
 182                                 priv->physical_device = phys_device;
 183                                 break;
 184                         }
 185                 }
 186
 187                 if(!priv->physical_device)
 188                         throw runtime_error("no usable physical devices found");
 189
 190                 priv->graphics_queue_family = gfx_queue_index;
 191
 192                 float queue_priority = 1.0f;
 193                 VkDeviceQueueCreateInfo queue_create_info = { };
 194                 queue_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
 195                 queue_create_info.queueFamilyIndex = gfx_queue_index;
 196                 queue_create_info.queueCount = 1;
 197                 queue_create_info.pQueuePriorities = &queue_priority;
 198
 199                 extensions.clear();
 200                 extensions.push_back("VK_KHR_swapchain");
 201
 202                 VkPhysicalDeviceFeatures features = { };
 203                 features.geometryShader = (opts.enable_geometry_shader ? VK_TRUE : VK_FALSE);
 204                 features.tessellationShader = (opts.enable_tessellation_shader ? VK_TRUE : VK_FALSE);
 205
 206                 VkDeviceCreateInfo device_create_info = { };
 207                 device_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
 208                 device_create_info.queueCreateInfoCount = 1;
 209                 device_create_info.pQueueCreateInfos = &queue_create_info;
 210                 device_create_info.enabledExtensionCount = extensions.size();
 211                 device_create_info.ppEnabledExtensionNames = extensions.data();
 212                 device_create_info.pEnabledFeatures = &features;
 213
 214                 result = f.vkCreateDevice(priv->physical_device, &device_create_info, 0, &priv->device);
 215                 if(result!=VK_SUCCESS)
 216                         throw vulkan_error(result, "vkCreateDevice");
 217
 218                 f.vkGetDeviceQueue(priv->device, gfx_queue_index, 0, &priv->graphics_queue);
 219         }
 220         catch(...)
 221         {
 222                 if(priv->device)
 223                         f.vkDestroyDevice(priv->device, 0);
 224                 if(priv->surface)
 225                         f.vkDestroySurface(priv->instance, priv->surface, 0);
 226                 if(priv->debug_report_callback)
 227                         f.vkDestroyDebugReportCallback(priv->instance, priv->debug_report_callback, 0);
 228                 if(priv->instance)
 229                         f.vkDestroyInstance(priv->instance, 0);
 230                 delete priv;
 231                 throw;
 232         }
 233 }
 234
 235 VulkanContext::~VulkanContext()
 236 {
 237         const VulkanFunctions &f = priv->functions;
 238         f.vkDestroyDevice(priv->device, 0);
 239         f.vkDestroySurface(priv->instance, priv->surface, 0);
 240         if(priv->debug_report_callback)
 241                 f.vkDestroyDebugReportCallback(priv->instance, priv->debug_report_callback, 0);
 242         f.vkDestroyInstance(priv->instance, 0);
 243         delete priv;
 244 }
 245
 246 void (*VulkanContext::_get_function(const std::string &name) const)()
 247 {
 248         return vkGetInstanceProcAddr(priv->instance, name.c_str());
 249 }
 250
 251
 252 VulkanContext::Private::Private():
 253         instance(0),
 254         physical_device(0),
 255         device(0),
 256         graphics_queue(0),
 257         debug_report_callback(0)
 258 { }
 259
 260 VkBool32 VulkanContext::Private::debug_report_func(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT, uint64_t, size_t, int32_t, const char *, const char *message, void *)
 261 {
 262         IO::print(IO::cerr, "%s\n", message);
 263         if((flags&VK_DEBUG_REPORT_ERROR_BIT_EXT) && Debug::check_debugger()==Debug::GDB)
 264                 Debug::debug_break();
 265         return VK_FALSE;
 266 }
 267
 268 } // namespace Graphics
 269 } // namespace Msp
 270