export symbol for win

diff --git a/CMakeLists.txt b/CMakeLists.txt
index afdb8756401c7be9efd6596668941092553a5e99..ce63862803fa31774edd61b2328f9f642e74aca4 100644 (file)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 3.21)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.20)
 
 OPTION (VKH_BUILD_SHARED_LIB "Build using shared libraries" OFF)
 OPTION(VKH_ENABLE_VMA "enable Vulkan Memory Allocator" ON)
@@ -93,15 +93,16 @@ GET_DIRECTORY_PROPERTY (vkh_has_root_project PARENT_DIRECTORY)
 IF (vkh_has_root_project)
        IF (VKH_BUILD_SHARED_LIBS)
                ADD_LIBRARY("${PROJECT_NAME}" SHARED ${VKH_SRC})
+               TARGET_COMPILE_DEFINITIONS("${PROJECT_NAME}" PUBLIC -DVKH_SHARED_BUILD)
                setup_lib ("${PROJECT_NAME}")
        ELSE()
                ADD_LIBRARY("${PROJECT_NAME}" STATIC ${VKH_SRC})
-               target_compile_definitions("${PROJECT_NAME}" PUBLIC -DVKVG_STATIC_BUILD)
                setup_lib ("${PROJECT_NAME}")
        ENDIF()
 ELSE()
        ADD_LIBRARY("${PROJECT_NAME}_shared" SHARED ${VKH_SRC})
        SET_PROPERTY(TARGET "${PROJECT_NAME}_shared" PROPERTY POSITION_INDEPENDENT_CODE ON)
+       TARGET_COMPILE_DEFINITIONS("${PROJECT_NAME}_shared" PUBLIC -DVKH_SHARED_BUILD)
        setup_lib ("${PROJECT_NAME}_shared")
 
        ADD_LIBRARY("${PROJECT_NAME}_static" STATIC ${VKH_SRC})

diff --git a/include/vkh.h b/include/vkh.h
index 78a95fde2e80a40bf1cf556d51a51be3782e6222..0a6eada1e3eb012d45f19c30be5ceb0b558ca62c 100644 (file)
--- a/include/vkh.h
+++ b/include/vkh.h
@@ -55,6 +55,17 @@ typedef enum VmaMemoryUsage VmaMemoryUsage;
                assert(res == VK_SUCCESS);                                                                                                                                              \
        }                                                                                                                                                                                                       \
 }
+#ifndef vkh_public
+       #ifdef VKH_SHARED_BUILD
+               #if (defined(_WIN32) || defined(_WIN64))
+                       #define vkh_public __declspec(dllimport)
+               #else
+                       #define vkh_public __attribute__((visibility("default")))
+               #endif
+       #else
+               #define vkh_public 
+       #endif
+#endif
 
 typedef struct _vkh_app_t*             VkhApp;
 typedef struct _vkh_phy_t*             VkhPhyInfo;
@@ -67,150 +78,236 @@ typedef struct _vkh_presenter_t* VkhPresenter;
 /*************
  * VkhApp    *
  *************/
+vkh_public
 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[]);
+vkh_public
 void                vkh_app_destroy     (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);
+vkh_public
 void                vkh_app_enable_debug_messenger (VkhApp app, VkDebugUtilsMessageTypeFlagsEXT typeFlags,
                                                                                                        VkDebugUtilsMessageSeverityFlagsEXT severityFlags,
                                                                                                        PFN_vkDebugUtilsMessengerCallbackEXT callback);
 
+vkh_public
 VkPhysicalDeviceProperties          vkh_app_get_phy_properties (VkhApp app, uint32_t phyIndex);
 
 /*************
  * VkhPhy    *
  *************/
+vkh_public
 VkhPhyInfo          vkh_phyinfo_create         (VkPhysicalDevice phy, VkSurfaceKHR surface);
+vkh_public
 void                vkh_phyinfo_destroy                (VkhPhyInfo phy);
 
+vkh_public
 VkPhysicalDeviceProperties          vkh_phyinfo_get_properties          (VkhPhyInfo phy);
+vkh_public
 VkPhysicalDeviceMemoryProperties    vkh_phyinfo_get_memory_properties   (VkhPhyInfo phy);
 
+vkh_public
 void vkh_phyinfo_get_queue_fam_indices         (VkhPhyInfo phy, int* pQueue, int* gQueue, int* tQueue, int* cQueue);
+vkh_public
 VkQueueFamilyProperties* vkh_phyinfo_get_queues_props(VkhPhyInfo phy, uint32_t* qCount);
 
+vkh_public
 bool vkh_phyinfo_create_queues   (VkhPhyInfo phy, int qFam, uint32_t queueCount, const float* queue_priorities, VkDeviceQueueCreateInfo* const qInfo);
+vkh_public
 bool vkh_phyinfo_create_presentable_queues     (VkhPhyInfo phy, uint32_t queueCount, const float* queue_priorities, VkDeviceQueueCreateInfo* const qInfo);
+vkh_public
 bool phy_info_create_graphic_queues                    (VkhPhyInfo phy, uint32_t queueCount, const float* queue_priorities, VkDeviceQueueCreateInfo* const qInfo);
+vkh_public
 bool vkh_phyinfo_create_transfer_queues                (VkhPhyInfo phy, uint32_t queueCount, const float* queue_priorities, VkDeviceQueueCreateInfo* const qInfo);
+vkh_public
 bool vkh_phyinfo_create_compute_queues         (VkhPhyInfo phy, uint32_t queueCount, const float* queue_priorities, VkDeviceQueueCreateInfo* const qInfo);
 
+vkh_public
 bool vkh_phyinfo_try_get_extension_properties (VkhPhyInfo phy, const char* name, const VkExtensionProperties* properties);
 /*************
  * VkhDevice *
  *************/
+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
 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);
+vkh_public
 VkPhysicalDevice       vkh_device_get_phy      (VkhDevice dev);
 /**
  * @brief Retrieve @ref VkhApp instance used to create this VkhDevice.
  * @param dev
  * @return the VkhApp instace used to create the VkhDevice.
  */
+vkh_public
 VkhApp vkh_device_get_app      (VkhDevice dev);
 
+vkh_public
 void vkh_device_set_object_name (VkhDevice dev, VkObjectType objectType, uint64_t handle, const char *name);
 
+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);
 
 /****************
  * VkhPresenter *
  ****************/
+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_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);
 /************
  * VkhImage *
  ************/
+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,
                                                                        VmaMemoryUsage memprops,        VkImageUsageFlags usage);
+vkh_public
 VkhImage vkh_image_ms_create    (VkhDevice pDev, VkFormat format, VkSampleCountFlagBits num_samples, uint32_t width, uint32_t height,
                                                                        VmaMemoryUsage memprops,        VkImageUsageFlags usage);
+vkh_public
 VkhImage vkh_tex2d_array_create (VkhDevice pDev, VkFormat format, uint32_t width, uint32_t height, uint32_t layers,
                                                                        VmaMemoryUsage memprops, VkImageUsageFlags usage);
+vkh_public
 void vkh_image_set_sampler      (VkhImage img, VkSampler sampler);
+vkh_public
 void vkh_image_create_descriptor(VkhImage img, VkImageViewType viewType, VkImageAspectFlags aspectFlags, VkFilter magFilter, VkFilter minFilter,
                                                                        VkSamplerMipmapMode mipmapMode, VkSamplerAddressMode addressMode);
+vkh_public
 void vkh_image_create_view      (VkhImage img, VkImageViewType viewType, VkImageAspectFlags aspectFlags);
+vkh_public
 void vkh_image_create_sampler   (VkhImage img, VkFilter magFilter, VkFilter minFilter,
                                                                        VkSamplerMipmapMode mipmapMode, VkSamplerAddressMode addressMode);
+vkh_public
 void vkh_image_set_layout       (VkCommandBuffer cmdBuff, VkhImage image, VkImageAspectFlags aspectMask, VkImageLayout old_image_layout,
                                                                        VkImageLayout new_image_layout, VkPipelineStageFlags src_stages, VkPipelineStageFlags dest_stages);
+vkh_public
 void vkh_image_set_layout_subres(VkCommandBuffer cmdBuff, VkhImage image, VkImageSubresourceRange subresourceRange, VkImageLayout old_image_layout,
                                                                        VkImageLayout new_image_layout, VkPipelineStageFlags src_stages, VkPipelineStageFlags dest_stages);
+vkh_public
 void vkh_image_destroy_sampler  (VkhImage img);
+vkh_public
 void vkh_image_destroy          (VkhImage img);
+vkh_public
 void* vkh_image_map             (VkhImage img);
+vkh_public
 void vkh_image_unmap            (VkhImage img);
+vkh_public
 void vkh_image_set_name         (VkhImage img, const char* name);
+vkh_public
 uint64_t vkh_image_get_stride  (VkhImage img);
 
+vkh_public
 VkImage                 vkh_image_get_vkimage   (VkhImage img);
+vkh_public
 VkImageView             vkh_image_get_view      (VkhImage img);
+vkh_public
 VkImageLayout           vkh_image_get_layout    (VkhImage img);
+vkh_public
 VkSampler               vkh_image_get_sampler   (VkhImage img);
+vkh_public
 VkDescriptorImageInfo   vkh_image_get_descriptor(VkhImage img, VkImageLayout imageLayout);
 
 /*************
  * VkhBuffer *
  *************/
+vkh_public
 VkhBuffer   vkh_buffer_create   (VkhDevice pDev, VkBufferUsageFlags usage,
                                                                        VmaMemoryUsage memprops, VkDeviceSize size);
+vkh_public
 void        vkh_buffer_destroy  (VkhBuffer buff);
+vkh_public
 VkResult    vkh_buffer_map      (VkhBuffer buff);
+vkh_public
 void        vkh_buffer_unmap    (VkhBuffer buff);
 
+vkh_public
 VkBuffer    vkh_buffer_get_vkbuffer         (VkhBuffer buff);
+vkh_public
 void*       vkh_buffer_get_mapped_pointer   (VkhBuffer buff);
 
+vkh_public
 VkFence         vkh_fence_create                       (VkhDevice dev);
+vkh_public
 VkFence         vkh_fence_create_signaled      (VkhDevice dev);
+vkh_public
 VkSemaphore     vkh_semaphore_create           (VkhDevice dev);
+vkh_public
 VkEvent         vkh_event_create            (VkhDevice dev);
 
+vkh_public
 VkCommandPool   vkh_cmd_pool_create (VkhDevice dev, uint32_t qFamIndex, VkCommandPoolCreateFlags flags);
+vkh_public
 VkCommandBuffer vkh_cmd_buff_create (VkhDevice dev, VkCommandPool cmdPool, VkCommandBufferLevel level);
+vkh_public
 void vkh_cmd_buffs_create (VkhDevice dev, VkCommandPool cmdPool, VkCommandBufferLevel level, uint32_t count, VkCommandBuffer* cmdBuffs);
+vkh_public
 void vkh_cmd_begin  (VkCommandBuffer cmdBuff, VkCommandBufferUsageFlags flags);
+vkh_public
 void vkh_cmd_end    (VkCommandBuffer cmdBuff);
+vkh_public
 void vkh_cmd_submit (VkhQueue queue, VkCommandBuffer *pCmdBuff, VkFence fence);
+vkh_public
 void vkh_cmd_submit_with_semaphores(VkhQueue queue, VkCommandBuffer *pCmdBuff, VkSemaphore waitSemaphore,
                                                                        VkSemaphore signalSemaphore, VkFence fence);
 
+vkh_public
 void vkh_cmd_label_start   (VkCommandBuffer cmd, const char* name, const float color[]);
+vkh_public
 void vkh_cmd_label_end     (VkCommandBuffer cmd);
+vkh_public
 void vkh_cmd_label_insert  (VkCommandBuffer cmd, const char* name, const float color[4]);
 
+vkh_public
 VkShaderModule vkh_load_module(VkDevice dev, const char* path);
 
+vkh_public
 bool        vkh_memory_type_from_properties(VkPhysicalDeviceMemoryProperties* memory_properties, uint32_t typeBits,
                                                                                VkFlags requirements_mask, uint32_t *typeIndex);
+vkh_public
 char *      read_spv(const char *filename, size_t *psize);
+vkh_public
 uint32_t*   readFile(uint32_t* length, const char* filename);
 
+vkh_public
 void dumpLayerExts ();
 
+vkh_public
 void        set_image_layout(VkCommandBuffer cmdBuff, VkImage image, VkImageAspectFlags aspectMask, VkImageLayout old_image_layout,
                                          VkImageLayout new_image_layout, VkPipelineStageFlags src_stages, VkPipelineStageFlags dest_stages);
+vkh_public
 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);
 /////////////////////
+vkh_public
 VkhQueue    vkh_queue_create    (VkhDevice dev, uint32_t familyIndex, uint32_t qIndex);
+vkh_public
 void        vkh_queue_destroy   (VkhQueue queue);
 //VkhQueue    vkh_queue_find      (VkhDevice dev, VkQueueFlags flags);
 /////////////////////