Minor cleanup.

src/engine/platform/win_glimp.c

@@ -563,20 +563,23 @@ static bool GLW_SetMode(int mode, qboolean fullscreen) {
 
         if (r_renderAPICompareWindow->integer) {
             HWND hwnd2 = create_api_compare_window(glConfig.vidWidth, glConfig.vidHeight);
-            if (!vk_initialize(hwnd2)) {
+            vk_initialize(hwnd2);
+            g_wv.hWnd_vulkan = hwnd2;
+            /*if (!vk_initialize(hwnd2)) {
                 ShowWindow(hwnd2, SW_HIDE);
                 DestroyWindow(hwnd2);
                 ri.Printf(PRINT_WARNING, "GLW_SetMode: could not create API compare window");
             } else {
                 g_wv.hWnd_vulkan = hwnd2;
-            }
+            }*/
         }
     } else { // vulkan
-        if (!vk_initialize(hwnd)) {
+        vk_initialize(hwnd);
+        /*if (!vk_initialize(hwnd)) {
             ShowWindow(hwnd, SW_HIDE);
             DestroyWindow(hwnd);
             return false;
-        }
+        }*/
 
         g_wv.hWnd = hwnd;
         g_wv.hWnd_vulkan = hwnd;

src/engine/renderer/vk.cpp

@@ -543,38 +543,35 @@ static void deallocate_image_chunks() {
 
 VkPipeline create_pipeline(const Vk_Pipeline_Desc&);
 
-bool vk_initialize(HWND hwnd) {
+void vk_initialize(HWND hwnd) {
     vk_log_file = fopen("vk_dev.log", "w");
 
-    try {
+    vk.instance = create_instance();
-        auto& g = vk;
+    vk.physical_device = select_physical_device(vk.instance);
+    vk.surface = create_surface(vk.instance, hwnd);
+    vk.surface_format = select_surface_format(vk.physical_device, vk.surface);
 
-        g.instance = create_instance();
+    vk.queue_family_index = select_queue_family(vk.physical_device, vk.surface);
-        g.physical_device = select_physical_device(g.instance);
+    vk.device = create_device(vk.physical_device, vk.queue_family_index);
-        g.surface = create_surface(g.instance, hwnd);
+    vkGetDeviceQueue(vk.device, vk.queue_family_index, 0, &vk.queue);
-        g.surface_format = select_surface_format(g.physical_device, g.surface);
 
-        g.queue_family_index = select_queue_family(g.physical_device, g.surface);
+    vk.swapchain = create_swapchain(vk.physical_device, vk.device, vk.surface, vk.surface_format);
-        g.device = create_device(g.physical_device, g.queue_family_index);
-        vkGetDeviceQueue(g.device, g.queue_family_index, 0, &g.queue);
 
-        g.swapchain = create_swapchain(g.physical_device, g.device, g.surface, g.surface_format);
+    VK_CHECK(vkGetSwapchainImagesKHR(vk.device, vk.swapchain, &vk.swapchain_image_count, nullptr));
-
-        VK_CHECK(vkGetSwapchainImagesKHR(g.device, g.swapchain, &vk.swapchain_image_count, nullptr));
 
     if (vk.swapchain_image_count > MAX_SWAPCHAIN_IMAGES)
         ri.Error( ERR_FATAL, "initialize_vulkan: swapchain image count (%d) exceeded limit (%d)", vk.swapchain_image_count, MAX_SWAPCHAIN_IMAGES );
 
-        VK_CHECK(vkGetSwapchainImagesKHR(g.device, g.swapchain, &vk.swapchain_image_count, g.swapchain_images));
+    VK_CHECK(vkGetSwapchainImagesKHR(vk.device, vk.swapchain, &vk.swapchain_image_count, vk.swapchain_images));
 
     for (std::size_t i = 0; i < vk.swapchain_image_count; i++) {
         VkImageViewCreateInfo desc;
         desc.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
         desc.pNext = nullptr;
         desc.flags = 0;
-            desc.image = g.swapchain_images[i];
+        desc.image = vk.swapchain_images[i];
         desc.viewType = VK_IMAGE_VIEW_TYPE_2D;
-            desc.format = g.surface_format.format;
+        desc.format = vk.surface_format.format;
         desc.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
         desc.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
         desc.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
@@ -584,7 +581,7 @@ bool vk_initialize(HWND hwnd) {
         desc.subresourceRange.levelCount = 1;
         desc.subresourceRange.baseArrayLayer = 0;
         desc.subresourceRange.layerCount = 1;
-            VK_CHECK(vkCreateImageView(g.device, &desc, nullptr, &g.swapchain_image_views[i]));
+        VK_CHECK(vkCreateImageView(vk.device, &desc, nullptr, &vk.swapchain_image_views[i]));
     }
 
     {
@@ -594,7 +591,7 @@ bool vk_initialize(HWND hwnd) {
         desc.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT | VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
         desc.queueFamilyIndex = vk.queue_family_index;
 
-            VK_CHECK(vkCreateCommandPool(g.device, &desc, nullptr, &vk.command_pool));
+        VK_CHECK(vkCreateCommandPool(vk.device, &desc, nullptr, &vk.command_pool));
     }
 
     {
@@ -604,7 +601,7 @@ bool vk_initialize(HWND hwnd) {
         alloc_info.commandPool = vk.command_pool;
         alloc_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
         alloc_info.commandBufferCount = 1;
-            VK_CHECK(vkAllocateCommandBuffers(vk.device, &alloc_info, &g.command_buffer));
+        VK_CHECK(vkAllocateCommandBuffers(vk.device, &alloc_info, &vk.command_buffer));
     }
 
     //
@@ -873,11 +870,6 @@ bool vk_initialize(HWND hwnd) {
 
         vk.skybox_pipeline = create_pipeline(desc);
     }
-
-    } catch (const std::exception&) {
-        return false;
-    }
-    return true;
 }
 
 void vk_deinitialize() {

src/engine/renderer/vk.h

@@ -50,7 +50,7 @@ struct Vk_Image {
     VkDescriptorSet descriptor_set;
 };
 
-bool vk_initialize(HWND hwnd);
+void vk_initialize(HWND hwnd);
 void vk_deinitialize();
 void vk_destroy_resources();