save commit

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 05faf8e2badf01f0b403fccdc54714e338eb165d..991fb90dd0531c7aa27fa9921779508a08ee3c44 100644 (file)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -19,24 +19,30 @@ IF (CYGWIN)
 ENDIF()
 
 if (CMAKE_BUILD_TYPE STREQUAL "Debug")
-    ADD_DEFINITIONS (-DDEBUG)
-    OPTION(ENABLE_VALIDATION "enable vulkan validation layer" ON)
-    IF (UNIX)
-        ADD_COMPILE_OPTIONS(-Wall -Wno-extra -Wno-unknown-pragmas)
-    ELSEIF (MSVC)
-        ADD_COMPILE_OPTIONS(/W4 /wd4204 /wd4221 /wd4100)
-    ENDIF()
+  ADD_DEFINITIONS (-DDEBUG)
+  OPTION(ENABLE_VALIDATION "enable vulkan validation layer" ON)
+  IF (UNIX)
+    ADD_COMPILE_OPTIONS(-Wall -Wno-extra -Wno-unknown-pragmas)
+  ELSEIF (MSVC)
+    ADD_COMPILE_OPTIONS(/W4 /wd4204 /wd4221 /wd4100)
+  ENDIF()
 ELSE()
-    UNSET(ENABLE_VALIDATION CACHE)
-    IF (UNIX)
-        #ADD_COMPILE_OPTIONS(-w -fvisibility=hidden)
-        #ADD_COMPILE_OPTIONS(-flto)
-    ELSEIF(MSVC)
-        ADD_COMPILE_OPTIONS(/W0)
-        IF (${LANG} EQUAL "C" AND MSVC)
-            ADD_COMPILE_OPTIONS(/TC)
-        ENDIF ()
+  UNSET(ENABLE_VALIDATION CACHE)
+  IF (UNIX)
+    #ADD_COMPILE_OPTIONS(-w -fvisibility=hidden)
+    IF (CMAKE_C_COMPILER_ID STREQUAL "GNU")
+      ADD_COMPILE_OPTIONS(-flto)
+    ENDIF()
+    IF (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+      ADD_COMPILE_OPTIONS(-flto)
     ENDIF()
+    #ADD_COMPILE_OPTIONS(-fuse-ld=gold) #no effect
+  ELSEIF(MSVC)
+    ADD_COMPILE_OPTIONS(/W0)
+    IF (${LANG} EQUAL "C" AND MSVC)
+      ADD_COMPILE_OPTIONS(/TC)
+    ENDIF ()
+  ENDIF()
 ENDIF()
 
 

diff --git a/include/vkh.h b/include/vkh.h
index 512b40bcebc18e0b31ee7e7c47de791ee4ae998b..3e9a95ba1e384ecf289742e03b1fa4478d452dba 100644 (file)
--- a/include/vkh.h
+++ b/include/vkh.h
@@ -116,14 +116,6 @@ typedef enum VkhMemoryUsage {
 #define VKH_MO 0x00100000
 #define VKH_GO 0x40000000
 
-#define VK_CHECK_RESULT(f)                                                                                             \
-    {                                                                                                                  \
-        VkResult res = (f);                                                                                            \
-        if (res != VK_SUCCESS) {                                                                                       \
-            fprintf(stderr, "Fatal : VkResult is %d in %s at line %d\n", res, __FILE__, __LINE__);                     \
-            assert(res == VK_SUCCESS);                                                                                 \
-        }                                                                                                              \
-    }
 #ifndef vkh_public
 #ifdef VKH_SHARED_BUILD
 #if (defined(_WIN32) || defined(_WIN64))
@@ -138,6 +130,47 @@ typedef enum VkhMemoryUsage {
 #endif
 #endif
 
+
+#define VKH_LOG_ERR        0x00000001
+#define VKH_LOG_DEBUG      0x00000002
+#define VKH_LOG_INFO       0x00000004
+#define VKH_LOG_FULL       0xffffffff
+
+#ifdef DEBUG
+extern uint32_t vkh_log_level;
+#endif
+
+#ifndef LOG
+#ifdef DEBUG
+#define LOG(level, ...)                                                                                                \
+    {                                                                                                                  \
+        if ((vkh_log_level) & (level))                                                                                \
+            fprintf(stdout, __VA_ARGS__);                                                                              \
+    }
+#else
+#define LOG
+#endif
+#endif
+
+#define VK_CHECK_RESULT(f)                                                                                             \
+    {                                                                                                                  \
+        VkResult res = (f);                                                                                            \
+        if (res != VK_SUCCESS) {                                                                                       \
+            LOG(VKH_LOG_ERR, "Fatal : VkResult is %d in %s at line %d\n", res, __FILE__, __LINE__);                     \
+            assert(res == VK_SUCCESS);                                                                                 \
+        }                                                                                                              \
+    }
+
+#define VKH_CHECK_RESULT(status, f)                                                                                    \
+    {                                                                                                                  \
+        status = (f);                                                                                            \
+        if (status != VK_SUCCESS) {                                                                                       \
+            LOG(VKH_LOG_ERR, "Fatal : VkResult is %d in %s at line %d\n", status, __FILE__, __LINE__);                     \
+            assert(status == VK_SUCCESS);                                                                                 \
+        }                                                                                                              \
+    }
+
+
 typedef struct _vkh_app_t       *VkhApp;
 typedef struct _vkh_phy_t       *VkhPhyInfo;
 typedef struct _vkh_device_t    *VkhDevice;
@@ -153,10 +186,23 @@ vkh_public VkhApp     vkh_app_create(uint32_t version_major, uint32_t version_mi
                                      uint32_t enabledLayersCount, const char **enabledLayers, uint32_t ext_count,
                                      const char *extentions[]);
 vkh_public void       vkh_app_destroy(VkhApp app);
+/**
+ * @brief Get current status of vkh application
+ * @param app
+ * @return VkResult
+ */
+vkh_public VkResult   vkh_app_status (VkhApp app);
 vkh_public VkInstance vkh_app_get_inst(VkhApp app);
 // VkPhysicalDevice    vkh_app_select_phy  (VkhApp app, VkPhysicalDeviceType preferedPhyType);
 vkh_public VkhPhyInfo *vkh_app_get_phyinfos(VkhApp app, uint32_t *count, VkSurfaceKHR surface);
 vkh_public void        vkh_app_free_phyinfos(uint32_t count, VkhPhyInfo *infos);
+/**
+ * @brief Add a Debug utils messenger to this  VkhApp. It will be destroyed on VkhApp end.
+ * @param VKH application pointer containing vkInstance.
+ * @param Message type flags
+ * @param Message severity flags.
+ * @param optional message callback, if null a default one which print to stdout is configured.
+ */
 vkh_public void        vkh_app_enable_debug_messenger(VkhApp app, VkDebugUtilsMessageTypeFlagsEXT typeFlags,
                                                       VkDebugUtilsMessageSeverityFlagsEXT  severityFlags,
                                                       PFN_vkDebugUtilsMessengerCallbackEXT callback);
@@ -194,6 +240,7 @@ vkh_public bool vkh_phyinfo_try_get_extension_properties(VkhPhyInfo phy, const c
  *************/
 vkh_public VkhDevice        vkh_device_create(VkhApp app, VkhPhyInfo phyInfo, VkDeviceCreateInfo *pDevice_info);
 vkh_public VkhDevice        vkh_device_import(VkInstance inst, VkPhysicalDevice phy, VkDevice vkDev);
+vkh_public VkResult         vkh_device_status(VkhDevice dev);
 vkh_public void             vkh_device_destroy(VkhDevice dev);
 vkh_public void             vkh_device_init_debug_utils(VkhDevice dev);
 vkh_public VkDevice         vkh_device_get_vkdev(VkhDevice dev);
@@ -209,7 +256,7 @@ vkh_public void vkh_device_set_object_name(VkhDevice dev, VkObjectType objectTyp
 
 vkh_public VkSampler vkh_device_create_sampler(VkhDevice dev, VkFilter magFilter, VkFilter minFilter,
                                                VkSamplerMipmapMode mipmapMode, VkSamplerAddressMode addressMode);
-vkh_public void      vkh_device_destroy_sampler(VkhDevice dev, VkSampler sampler);
+vkh_public void vkh_device_destroy_sampler(VkhDevice dev, VkSampler sampler);
 
 /****************
  * VkhPresenter *
@@ -217,9 +264,9 @@ vkh_public void      vkh_device_destroy_sampler(VkhDevice dev, VkSampler sampler
 vkh_public VkhPresenter vkh_presenter_create(VkhDevice dev, uint32_t presentQueueFamIdx, VkSurfaceKHR surface,
                                              uint32_t width, uint32_t height, VkFormat preferedFormat,
                                              VkPresentModeKHR presentMode);
-vkh_public void         vkh_presenter_destroy(VkhPresenter r);
-vkh_public bool         vkh_presenter_draw(VkhPresenter r);
-vkh_public bool         vkh_presenter_acquireNextImage(VkhPresenter r, VkFence fence, VkSemaphore semaphore);
+vkh_public void vkh_presenter_destroy(VkhPresenter r);
+vkh_public bool vkh_presenter_draw(VkhPresenter r);
+vkh_public bool vkh_presenter_acquireNextImage(VkhPresenter r, VkFence fence, VkSemaphore semaphore);
 vkh_public void vkh_presenter_build_blit_cmd(VkhPresenter r, VkImage blitSource, uint32_t width, uint32_t height);
 vkh_public void vkh_presenter_create_swapchain(VkhPresenter r);
 vkh_public void vkh_presenter_get_size(VkhPresenter r, uint32_t *pWidth, uint32_t *pHeight);
@@ -229,6 +276,7 @@ vkh_public void vkh_presenter_get_size(VkhPresenter r, uint32_t *pWidth, uint32_
 vkh_public VkhImage vkh_image_import(VkhDevice pDev, VkImage vkImg, VkFormat format, uint32_t width, uint32_t height);
 vkh_public VkhImage vkh_image_create(VkhDevice pDev, VkFormat format, uint32_t width, uint32_t height,
                                      VkImageTiling tiling, VkhMemoryUsage memprops, VkImageUsageFlags usage);
+vkh_public VkResult vkh_image_status(VkhImage img);
 vkh_public VkhImage vkh_image_ms_create(VkhDevice pDev, VkFormat format, VkSampleCountFlagBits num_samples,
                                         uint32_t width, uint32_t height, VkhMemoryUsage memprops,
                                         VkImageUsageFlags usage);

diff --git a/src/vkh_app.c b/src/vkh_app.c
index e3696b1f9186cfad59995a0144a233efba1bd0a2..a42068c40ffb039c6a335460a4143d1a8f613167 100644 (file)
--- a/src/vkh_app.c
+++ b/src/vkh_app.c
@@ -20,11 +20,12 @@
  * THE SOFTWARE.
  */
 #include "vkh_app.h"
-// #include "vk_mem_alloc.h"
 
 #define ENGINE_NAME    "vkhelpers"
 #define ENGINE_VERSION 1
+uint32_t vkh_log_level = VKH_LOG_DEBUG;
 
+//default debug messenger callback enabled with 'vkh_app_enable_debug_messenger'
 VkBool32 debugUtilsMessengerCallback(VkDebugUtilsMessageSeverityFlagBitsEXT      messageSeverity,
                                      VkDebugUtilsMessageTypeFlagsEXT             messageTypes,
                                      const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData, void *pUserData) {
@@ -62,7 +63,15 @@ VkBool32 debugUtilsMessengerCallback(VkDebugUtilsMessageSeverityFlagBitsEXT
 
 VkhApp vkh_app_create(uint32_t version_major, uint32_t version_minor, const char *app_name, uint32_t enabledLayersCount,
                       const char **enabledLayers, uint32_t ext_count, const char *extentions[]) {
+    uint32_t apiVersion;
+    vkEnumerateInstanceVersion(&apiVersion);
+    LOG(VKH_LOG_INFO, "VkhApp create: instance api version = %d.%d", VK_API_VERSION_MAJOR(apiVersion), VK_API_VERSION_MINOR(apiVersion));
+
     VkhApp app = (VkhApp)malloc(sizeof(vkh_app_t));
+    if (!app) {
+        LOG(VKH_LOG_ERR, "VkhApp creation failed, out of memory.");
+        return NULL;
+    }
 
     VkApplicationInfo infos = {.sType              = VK_STRUCTURE_TYPE_APPLICATION_INFO,
                                .pApplicationName   = app_name,
@@ -82,7 +91,7 @@ VkhApp vkh_app_create(uint32_t version_major, uint32_t version_minor, const char
                                       .enabledLayerCount       = enabledLayersCount,
                                       .ppEnabledLayerNames     = enabledLayers};
 
-    VK_CHECK_RESULT(vkCreateInstance(&inst_info, NULL, &app->inst));
+    VKH_CHECK_RESULT(app->status, vkCreateInstance(&inst_info, NULL, &app->inst));
     app->infos          = infos;
     app->debugMessenger = VK_NULL_HANDLE;
     return app;
@@ -92,14 +101,14 @@ void vkh_app_destroy(VkhApp app) {
     if (app->debugMessenger != VK_NULL_HANDLE) {
         PFN_vkDestroyDebugUtilsMessengerEXT DestroyDebugUtilsMessenger =
             (PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr(app->inst, "vkDestroyDebugUtilsMessengerEXT");
-
         DestroyDebugUtilsMessenger(app->inst, app->debugMessenger, VK_NULL_HANDLE);
     }
     vkDestroyInstance(app->inst, NULL);
     free(app);
 }
+VkResult vkh_app_status(VkhApp app) { return app==NULL ? VK_ERROR_UNKNOWN : app->status; }
 
-VkInstance vkh_app_get_inst(VkhApp app) { return app->inst; }
+VkInstance vkh_app_get_inst(VkhApp app) { return vkh_app_status(app) ? VK_NULL_HANDLE : app->inst; }
 
 VkhPhyInfo *vkh_app_get_phyinfos(VkhApp app, uint32_t *count, VkSurfaceKHR surface) {
     VK_CHECK_RESULT(vkEnumeratePhysicalDevices(app->inst, count, NULL));
@@ -119,13 +128,7 @@ void vkh_app_free_phyinfos(uint32_t count, VkhPhyInfo *infos) {
         vkh_phyinfo_destroy(infos[i]);
     free(infos);
 }
-/**
- * @brief Add a Debug utils messenger to this  VkhApp. It will be destroyed on VkhApp end.
- * @param VKH application pointer containing vkInstance.
- * @param Message type flags
- * @param Message severity flags.
- * @param optional message callback, if null a default one which print to stdout is configured.
- */
+
 void vkh_app_enable_debug_messenger(VkhApp app, VkDebugUtilsMessageTypeFlagsEXT typeFlags,
                                     VkDebugUtilsMessageSeverityFlagsEXT  severityFlags,
                                     PFN_vkDebugUtilsMessengerCallbackEXT callback) {

diff --git a/src/vkh_app.h b/src/vkh_app.h
index b56599839ca4c97f5f2150605cbd39ab1bdc6456..b01c01c629fc16886bb9ad90899ef2d43c168fce 100644 (file)
--- a/src/vkh_app.h
+++ b/src/vkh_app.h
@@ -50,6 +50,7 @@ typedef struct _vkh_app_t {
     VkApplicationInfo        infos;
     VkInstance               inst;
     VkDebugUtilsMessengerEXT debugMessenger;
+    VkResult                 status;
 } vkh_app_t;
 #ifdef __cplusplus
 }

diff --git a/src/vkh_device.c b/src/vkh_device.c
index d227acd939185554937e4b02f288b11f108e8cba..66ec7a71120b23b4af76db427ecebb8c8a0c0692 100644 (file)
--- a/src/vkh_device.c
+++ b/src/vkh_device.c
@@ -53,9 +53,10 @@ VkhDevice vkh_device_import(VkInstance inst, VkPhysicalDevice phy, VkDevice vkDe
 
     return dev;
 }
-VkDevice         vkh_device_get_vkdev(VkhDevice dev) { return dev->dev; }
-VkPhysicalDevice vkh_device_get_phy(VkhDevice dev) { return dev->phy; }
-VkhApp           vkh_device_get_app(VkhDevice dev) { return dev->vkhApplication; }
+VkResult         vkh_device_status(VkhDevice dev) { return dev==NULL ? VK_ERROR_UNKNOWN : dev->status; }
+VkDevice         vkh_device_get_vkdev(VkhDevice dev) { return vkh_device_status(dev) ? VK_NULL_HANDLE : dev->dev; }
+VkPhysicalDevice vkh_device_get_phy(VkhDevice dev) { return vkh_device_status(dev) ? VK_NULL_HANDLE : dev->phy; }
+VkhApp           vkh_device_get_app(VkhDevice dev) { return vkh_device_status(dev) ? NULL : dev->vkhApplication; }
 /**
  * @brief get instance proc addresses for debug utils (name, label,...)
  * @param vkh device

diff --git a/src/vkh_device.h b/src/vkh_device.h
index a70da5a176ba693a31adf67fd808828820ce3f17..b21e41d6ea4b37a1eb78d2958e0e1211e7e2eef0 100644 (file)
--- a/src/vkh_device.h
+++ b/src/vkh_device.h
@@ -41,6 +41,7 @@ typedef struct _vkh_device_t {
     VmaAllocator allocator;
 #endif
     VkhApp vkhApplication;
+    VkResult status;
 } vkh_device_t;
 
 #ifdef __cplusplus

diff --git a/src/vkh_image.c b/src/vkh_image.c
index 76fd231a76b780fcd29243adaf6d064545680fe8..fc2ac3eb8271ec48eea067e2684ee572f09366a0 100644 (file)
--- a/src/vkh_image.c
+++ b/src/vkh_image.c
@@ -54,7 +54,7 @@ VkhImage _vkh_image_create(VkhDevice pDev, VkImageType imageType, VkFormat forma
     img->view  = VK_NULL_HANDLE;*/
 #ifdef VKH_USE_VMA
     VmaAllocationCreateInfo allocInfo = {.usage = (VmaMemoryUsage)memprops};
-    VK_CHECK_RESULT(vmaCreateImage(pDev->allocator, pInfo, &allocInfo, &img->image, &img->alloc, &img->allocInfo));
+    VKH_CHECK_RESULT(img->status, vmaCreateImage(pDev->allocator, pInfo, &allocInfo, &img->image, &img->alloc, &img->allocInfo));
 #else
     VK_CHECK_RESULT(vkCreateImage(pDev->dev, pInfo, NULL, &img->image));
     VkMemoryRequirements memReq;
@@ -108,6 +108,8 @@ void vkh_image_reference(VkhImage img) {
     img->references++;
     mtx_unlock(&img->mutex);
 }
+VkResult vkh_image_status(VkhImage img) { return img==NULL ? VK_ERROR_UNKNOWN : img->status; }
+
 VkhImage vkh_tex2d_array_create(VkhDevice pDev, VkFormat format, uint32_t width, uint32_t height, uint32_t layers,
                                 VkhMemoryUsage memprops, VkImageUsageFlags usage) {
     return _vkh_image_create(pDev, VK_IMAGE_TYPE_2D, format, width, height, memprops, usage, VK_SAMPLE_COUNT_1_BIT,

diff --git a/src/vkh_image.h b/src/vkh_image.h
index b1fc182e129cefcb2ab4871a9fc5469b8f94e845..64c2164a6e3b8c12944fd597db4e6d44eae1e1e7 100644 (file)
--- a/src/vkh_image.h
+++ b/src/vkh_image.h
@@ -31,6 +31,7 @@ extern "C" {
 #include "deps/tinycthread.h"
 
 typedef struct _vkh_image_t {
+    VkResult          status;
     VkhDevice         pDev;
     VkImageCreateInfo infos;
     VkImage           image;