Prevent deadlock, improve logger

src/VulkanUtils.c

@@ -12,16 +12,60 @@ static VkDebugReportCallbackEXT debugReportCallback;
 #define VK_ERROR_CASE(error)  \
     case error: return #error
 
-const char* getVulkanErrorString(VkResult r) {
+const char* getVulkanResultString(VkResult r) {
     switch(r) {
+        VK_ERROR_CASE(VK_SUCCESS);
+        VK_ERROR_CASE(VK_NOT_READY);
+        VK_ERROR_CASE(VK_TIMEOUT);
+        VK_ERROR_CASE(VK_EVENT_SET);
+        VK_ERROR_CASE(VK_EVENT_RESET);
+        VK_ERROR_CASE(VK_INCOMPLETE);
         VK_ERROR_CASE(VK_ERROR_OUT_OF_HOST_MEMORY);
         VK_ERROR_CASE(VK_ERROR_OUT_OF_DEVICE_MEMORY);
         VK_ERROR_CASE(VK_ERROR_INITIALIZATION_FAILED);
+        VK_ERROR_CASE(VK_ERROR_DEVICE_LOST);
+        VK_ERROR_CASE(VK_ERROR_MEMORY_MAP_FAILED);
         VK_ERROR_CASE(VK_ERROR_LAYER_NOT_PRESENT);
         VK_ERROR_CASE(VK_ERROR_EXTENSION_NOT_PRESENT);
+        VK_ERROR_CASE(VK_ERROR_FEATURE_NOT_PRESENT);
         VK_ERROR_CASE(VK_ERROR_INCOMPATIBLE_DRIVER);
-        default: return "unknown";
-    }
+        VK_ERROR_CASE(VK_ERROR_TOO_MANY_OBJECTS);
+        VK_ERROR_CASE(VK_ERROR_FORMAT_NOT_SUPPORTED);
+        VK_ERROR_CASE(VK_ERROR_FRAGMENTED_POOL);
+        VK_ERROR_CASE(VK_ERROR_UNKNOWN);
+        VK_ERROR_CASE(VK_ERROR_OUT_OF_POOL_MEMORY);
+        VK_ERROR_CASE(VK_ERROR_INVALID_EXTERNAL_HANDLE);
+        VK_ERROR_CASE(VK_ERROR_FRAGMENTATION);
+        VK_ERROR_CASE(VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS);
+        VK_ERROR_CASE(VK_PIPELINE_COMPILE_REQUIRED);
+        VK_ERROR_CASE(VK_ERROR_SURFACE_LOST_KHR);
+        VK_ERROR_CASE(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR);
+        VK_ERROR_CASE(VK_SUBOPTIMAL_KHR);
+        VK_ERROR_CASE(VK_ERROR_OUT_OF_DATE_KHR);
+        VK_ERROR_CASE(VK_ERROR_INCOMPATIBLE_DISPLAY_KHR);
+        VK_ERROR_CASE(VK_ERROR_VALIDATION_FAILED_EXT);
+        VK_ERROR_CASE(VK_ERROR_INVALID_SHADER_NV);
+        VK_ERROR_CASE(VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR);
+        VK_ERROR_CASE(VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR);
+        VK_ERROR_CASE(VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR);
+        VK_ERROR_CASE(VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR);
+        VK_ERROR_CASE(VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR);
+        VK_ERROR_CASE(VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR);
+        VK_ERROR_CASE(VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT);
+        VK_ERROR_CASE(VK_ERROR_NOT_PERMITTED_KHR);
+        VK_ERROR_CASE(VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT);
+        VK_ERROR_CASE(VK_THREAD_IDLE_KHR);
+        VK_ERROR_CASE(VK_THREAD_DONE_KHR);
+        VK_ERROR_CASE(VK_OPERATION_DEFERRED_KHR);
+        VK_ERROR_CASE(VK_OPERATION_NOT_DEFERRED_KHR);
+        VK_ERROR_CASE(VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR);
+        VK_ERROR_CASE(VK_ERROR_COMPRESSION_EXHAUSTED_EXT);
+        VK_ERROR_CASE(VK_INCOMPATIBLE_SHADER_BINARY_EXT);
+        VK_ERROR_CASE(VK_PIPELINE_BINARY_MISSING_KHR);
+        VK_ERROR_CASE(VK_ERROR_NOT_ENOUGH_SPACE_KHR);
+        default: break;
+    }
+    return "unknown";
 }
 
 static PFN_vkVoidFunction getVulkanFunction(const char* name) {
@@ -252,7 +296,7 @@ bool hasVulkanExtension(VkPhysicalDevice pd, const char* extension) {
     if(r != VK_SUCCESS) {
         LOG_ERROR(
             "Cannot get physical device extension properties: %s",
-            getVulkanErrorString(r));
+            getVulkanResultString(r));
         return false;
     }
     for(u32 i = 0; i < c; i++) {

src/VulkanUtils.h

@@ -5,15 +5,15 @@
 #include <GLFW/glfw3.h>
 #include <core/Utility.h>
 
-const char* getVulkanErrorString(VkResult r);
-
-#define VK_ASSERT(a)                                                         \
-    do {                                                                     \
-        VkResult vkResult = (a);                                             \
-        if(vkResult != VK_SUCCESS) {                                         \
-            LOG_ERROR("Vulkan error: %s\n", getVulkanErrorString(vkResult)); \
-            return true;                                                     \
-        }                                                                    \
+const char* getVulkanResultString(VkResult r);
+
+#define VK_ASSERT(a)                                                          \
+    do {                                                                      \
+        VkResult vkResult = (a);                                              \
+        if(vkResult != VK_SUCCESS) {                                          \
+            LOG_ERROR("Vulkan error: %s\n", getVulkanResultString(vkResult)); \
+            return true;                                                      \
+        }                                                                     \
     } while(false)
 
 bool initVulkanInstance();

src/VulkanWrapper.c

@@ -417,7 +417,12 @@ bool initVulkan() {
            initCommandPool() || initFrames();
 }
 
+static bool shouldWait = false;
+
 static bool render() {
+    if(shouldWait) {
+        return false;
+    }
     Frame* f = frames + currentFrame;
     VK_ASSERT(vkWaitForFences(device, 1, &f->inFlightFence, true, UINT64_MAX));
     VK_ASSERT(vkResetFences(device, 1, &f->inFlightFence));
@@ -459,7 +464,9 @@ static bool render() {
 }
 
 void renderVulkan() {
-    render();
+    if(render()) {
+        shouldWait = true;
+    }
 }
 
 void destroyVulkan(void) {