build static and shared libs

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7bf13029b87a04f42eebbcba82c049c1da997deb..a23b25e4d5905ae4f620ae7fe7d9ba1da4f7b04e 100644 (file)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -11,35 +11,51 @@ IF(NOT CMAKE_BUILD_TYPE)
 ENDIF()
 MESSAGE(STATUS "${CMAKE_BUILD_TYPE} build.")
 
+if (CMAKE_BUILD_TYPE STREQUAL "Debug")
+       ADD_DEFINITIONS (-DDEBUG)
+ENDIF()
+
 FIND_PACKAGE(Vulkan REQUIRED)
 FIND_PACKAGE(GLFW3 REQUIRED)
 
 INCLUDE(GNUInstallDirs)
 
-FILE(GLOB VKH_SRC src/*.c)
+FILE(GLOB sources src/*.c)
 
-ADD_LIBRARY(${PROJECT_NAME} SHARED ${VKH_SRC})
-
-SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES
-               VERSION ${PROJECT_VERSION}
-               SOVERSION 1
-                PUBLIC_HEADER include/vkh.h
-)
-
-TARGET_INCLUDE_DIRECTORIES(${PROJECT_NAME} PRIVATE
+ADD_LIBRARY(objlib OBJECT ${sources})
+TARGET_INCLUDE_DIRECTORIES(objlib PRIVATE
                ${CMAKE_CURRENT_SOURCE_DIR}/include
                ${CMAKE_CURRENT_SOURCE_DIR}/src
 )
+SET_PROPERTY(TARGET objlib PROPERTY POSITION_INDEPENDENT_CODE 1) #PIC option for shared lib
 
-TARGET_LINK_LIBRARIES(${PROJECT_NAME}
-       ${Vulkan_LIBRARY}
-       ${GLFW3_LIBRARY}
-)
+ADD_LIBRARY("${PROJECT_NAME}_shared" SHARED $<TARGET_OBJECTS:objlib>)
+ADD_LIBRARY("${PROJECT_NAME}_static" STATIC $<TARGET_OBJECTS:objlib>)
 
 CONFIGURE_FILE(vkh.pc.in vkh.pc @ONLY)
-
 INSTALL(FILES ${CMAKE_BINARY_DIR}/vkh.pc DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/pkgconfig)
-INSTALL(TARGETS ${PROJECT_NAME}
-       LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-       PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
 
+FUNCTION (setup_lib LibName)
+       SET_TARGET_PROPERTIES(${LibName} PROPERTIES
+                       VERSION ${PROJECT_VERSION}
+                       SOVERSION 1
+                       PUBLIC_HEADER include/vkh.h
+       )
+       TARGET_LINK_LIBRARIES(${LibName}
+               ${Vulkan_LIBRARY}
+               ${GLFW3_LIBRARY}
+       )
+       INSTALL(TARGETS ${LibName}
+               LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+               ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+               PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+ENDFUNCTION ()
+
+setup_lib ("${PROJECT_NAME}_static")
+setup_lib ("${PROJECT_NAME}_shared")
+
+
+#get_cmake_property(_variableNames VARIABLES)
+#foreach (_variableName ${_variableNames})
+#message(STATUS "${_variableName}=${${_variableName}}")
+#endforeach()

diff --git a/include/vkh.h b/include/vkh.h
index efee4a79c3c5d0a4207f882ab2467663f489fe18..90a98e916c029c8df900f72afedfc96786b5cd24 100644 (file)
--- a/include/vkh.h
+++ b/include/vkh.h
@@ -14,14 +14,15 @@
 
 #define VK_CHECK_RESULT(f)                                                                                                                                                             \
 {                                                                                                                                                                                                              \
-    VkResult res = (f);                                                                                                                                                                        \
-    if (res != VK_SUCCESS)                                                                                                                                                             \
-    {                                                                                                                                                                                                  \
-        printf("Fatal : VkResult is %d in %s at line %d\n", res,  __FILE__, __LINE__); \
-        assert(res == VK_SUCCESS);                                                                                                                                             \
-    }                                                                                                                                                                                                  \
+       VkResult res = (f);                                                                                                                                                                     \
+       if (res != VK_SUCCESS)                                                                                                                                                          \
+       {                                                                                                                                                                                                       \
+               printf("Fatal : VkResult is %d in %s at line %d\n", res,  __FILE__, __LINE__); \
+               assert(res == VK_SUCCESS);                                                                                                                                              \
+       }                                                                                                                                                                                                       \
 }
 
+typedef struct _vkh_app_t*             VkhApp;
 typedef struct _vkh_device_t*   VkhDevice;
 typedef struct _vkh_image_t*    VkhImage;
 typedef struct _vkh_buffer_t*   VkhBuffer;
@@ -29,25 +30,25 @@ typedef struct _vkh_presenter_t*    VkhPresenter;
 
 ///////////////////////////////
 VkhImage vkh_image_create       (VkhDevice pDev, VkFormat format, uint32_t width, uint32_t height, VkImageTiling tiling,
-                                    VkMemoryPropertyFlags memprops,    VkImageUsageFlags usage);
+                                                                       VkMemoryPropertyFlags memprops, VkImageUsageFlags usage);
 VkhImage vkh_image_ms_create    (VkhDevice pDev, VkFormat format, VkSampleCountFlagBits num_samples, uint32_t width, uint32_t height,
-                                    VkMemoryPropertyFlags memprops,    VkImageUsageFlags usage);
+                                                                       VkMemoryPropertyFlags memprops, VkImageUsageFlags usage);
 VkhImage vkh_tex2d_array_create (VkhDevice pDev, VkFormat format, uint32_t width, uint32_t height, uint32_t layers,
-                                    VkMemoryPropertyFlags memprops, VkImageUsageFlags usage);
+                                                                       VkMemoryPropertyFlags memprops, VkImageUsageFlags usage);
 void vkh_image_create_descriptor(VkhImage img, VkImageViewType viewType, VkImageAspectFlags aspectFlags, VkFilter magFilter, VkFilter minFilter,
-                                    VkSamplerMipmapMode mipmapMode, VkSamplerAddressMode addressMode);
+                                                                       VkSamplerMipmapMode mipmapMode, VkSamplerAddressMode addressMode);
 void vkh_image_create_view      (VkhImage img, VkImageViewType viewType, VkImageAspectFlags aspectFlags);
 void vkh_image_create_sampler   (VkhImage img, VkFilter magFilter, VkFilter minFilter,
-                                    VkSamplerMipmapMode mipmapMode, VkSamplerAddressMode addressMode);
+                                                                       VkSamplerMipmapMode mipmapMode, VkSamplerAddressMode addressMode);
 void vkh_image_set_layout       (VkCommandBuffer cmdBuff, VkhImage image, VkImageAspectFlags aspectMask,
-                                    VkImageLayout new_image_layout, VkPipelineStageFlags src_stages, VkPipelineStageFlags dest_stages);
+                                                                       VkImageLayout new_image_layout, VkPipelineStageFlags src_stages, VkPipelineStageFlags dest_stages);
 void vkh_image_set_layout_subres(VkCommandBuffer cmdBuff, VkhImage image, VkImageSubresourceRange subresourceRange,
-                                    VkImageLayout new_image_layout, VkPipelineStageFlags src_stages, VkPipelineStageFlags dest_stages);
+                                                                       VkImageLayout new_image_layout, VkPipelineStageFlags src_stages, VkPipelineStageFlags dest_stages);
 void vkh_image_destroy          (VkhImage img);
 
 ////////////////////////////////
 VkhBuffer   vkh_buffer_create   (VkhDevice pDev, VkBufferUsageFlags usage,
-                                    VkMemoryPropertyFlags memoryPropertyFlags, VkDeviceSize size);
+                                                                       VkMemoryPropertyFlags memoryPropertyFlags, VkDeviceSize size);
 void        vkh_buffer_destroy  (VkhBuffer buff);
 VkResult    vkh_buffer_map      (VkhBuffer buff);
 void        vkh_buffer_unmap    (VkhBuffer buff);
@@ -64,21 +65,21 @@ void vkh_cmd_begin  (VkCommandBuffer cmdBuff, VkCommandBufferUsageFlags flags);
 void vkh_cmd_end    (VkCommandBuffer cmdBuff);
 void vkh_cmd_submit (VkQueue queue, VkCommandBuffer *pCmdBuff, VkFence fence);
 void vkh_cmd_submit_with_semaphores(VkQueue queue, VkCommandBuffer *pCmdBuff, VkSemaphore waitSemaphore,
-                                    VkSemaphore signalSemaphore, VkFence fence);
+                                                                       VkSemaphore signalSemaphore, VkFence fence);
 
 VkPhysicalDevice vkh_find_phy (VkInstance inst, VkPhysicalDeviceType phyType);
 
 VkShaderModule vkh_load_module(VkDevice dev, const char* path);
 
 bool        memory_type_from_properties(VkPhysicalDeviceMemoryProperties* memory_properties, uint32_t typeBits,
-                                        VkFlags requirements_mask, uint32_t *typeIndex);
+                                                                               VkFlags requirements_mask, uint32_t *typeIndex);
 char *      read_spv(const char *filename, size_t *psize);
 uint32_t*   readFile(uint32_t* length, const char* filename);
 
 void dumpLayerExts ();
 
 void        set_image_layout(VkCommandBuffer cmdBuff, VkImage image, VkImageAspectFlags aspectMask, VkImageLayout old_image_layout,
-                      VkImageLayout new_image_layout, VkPipelineStageFlags src_stages, VkPipelineStageFlags dest_stages);
+                                         VkImageLayout new_image_layout, VkPipelineStageFlags src_stages, VkPipelineStageFlags dest_stages);
 void        set_image_layout_subres(VkCommandBuffer cmdBuff, VkImage image, VkImageSubresourceRange subresourceRange, VkImageLayout old_image_layout,
-                      VkImageLayout new_image_layout, VkPipelineStageFlags src_stages, VkPipelineStageFlags dest_stages);
+                                         VkImageLayout new_image_layout, VkPipelineStageFlags src_stages, VkPipelineStageFlags dest_stages);
 #endif

diff --git a/src/vkh_app.c b/src/vkh_app.c
new file mode 100644 (file)
index 0000000..f4bea7a
--- /dev/null
+++ b/src/vkh_app.c
@@ -0,0 +1,64 @@
+#include "vkh_app.h"
+
+#define ENGINE_NAME     "vkheplers"
+#define ENGINE_VERSION  1
+
+VkhApp vkh_app_create (const char* app_name, const char* extentions[], int ext_count) {
+    VkhApp app = (VkhApp)malloc(sizeof(vkh_app_t));
+
+    VkApplicationInfo infos = { .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
+                                .pApplicationName = app_name,
+                                .applicationVersion = 1,
+                                .pEngineName = ENGINE_NAME,
+                                .engineVersion = ENGINE_VERSION,
+                                .apiVersion = VK_API_VERSION_1_0};
+#if DEBUG
+    const uint32_t enabledLayersCount = 1;
+    //const char* enabledLayers[] = {"VK_LAYER_LUNARG_core_validation"};
+    const char* enabledLayers[] = {"VK_LAYER_LUNARG_standard_validation"};
+#else
+    const uint32_t enabledLayersCount = 0;
+    const char* enabledLayers[] = NULL;
+#endif
+
+    VkInstanceCreateInfo inst_info = { .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
+                                       .pApplicationInfo = &infos,
+                                       .enabledExtensionCount = ext_count,
+                                       .ppEnabledExtensionNames = extentions,
+                                       .enabledLayerCount = enabledLayersCount,
+                                       .ppEnabledLayerNames = enabledLayers };
+
+    VK_CHECK_RESULT(vkCreateInstance (&inst_info, NULL, &app->inst));
+    return app;
+}
+
+void vkh_app_destroy (VkhApp app){
+    vkDestroyInstance (app->inst, NULL);
+    free (app);
+}
+
+VkPhysicalDevice vkh_app_select_phy (VkhApp app, VkPhysicalDeviceType preferedPhyType) {
+    uint32_t gpu_count = 0;
+
+    VK_CHECK_RESULT(vkEnumeratePhysicalDevices (app->inst, &gpu_count, NULL));
+
+    VkPhysicalDevice phys[gpu_count];
+
+    VK_CHECK_RESULT(vkEnumeratePhysicalDevices (app->inst, &gpu_count, &phys));
+
+    if (gpu_count == 1)
+        return phys[0];
+
+    for (int i=0; i<gpu_count; i++){
+        VkPhysicalDeviceProperties phy;
+        vkGetPhysicalDeviceProperties (phys[i], &phy);
+        if (phy.deviceType & preferedPhyType){
+            printf ("GPU: %s  vulkan:%d.%d.%d driver:%d\n", phy.deviceName,
+                    phy.apiVersion>>22, phy.apiVersion>>12&2048, phy.apiVersion&8191,
+                    phy.driverVersion);
+            return phys[i];
+        }
+    }
+    fprintf (stderr, "No suitable GPU found\n");
+    exit (-1);
+}

diff --git a/src/vkh_app.h b/src/vkh_app.h
new file mode 100644 (file)
index 0000000..726c9a8
--- /dev/null
+++ b/src/vkh_app.h
@@ -0,0 +1,9 @@
+#ifndef VKH_APP_H
+#define VKH_APP_H
+
+#include "vkh.h"
+
+typedef struct _vkh_app_t{
+       VkInstance          inst;
+}vkh_app_t;
+#endif