opaque pointers

diff --git a/vkh_buffer.c b/vkh_buffer.c
index 8de3025bed61286e8e92a34aa669e21146a0e709..9e4f48eff4366eaf5a052e8809f34653dd9864dd 100644 (file)
--- a/vkh_buffer.c
+++ b/vkh_buffer.c
@@ -1,7 +1,8 @@
 #include "vkh_buffer.h"
-#include "vkhelpers.h"
+#include "vkh_device.h"
 
-void vkh_buffer_create(vkh_device *pDev, VkBufferUsageFlags usage, VkMemoryPropertyFlags memoryPropertyFlags, VkDeviceSize size, vkh_buffer* buff){
+VkhBuffer vkh_buffer_create(VkhDevice pDev, VkBufferUsageFlags usage, VkMemoryPropertyFlags memoryPropertyFlags, VkDeviceSize size){
+    VkhBuffer buff = (VkhBuffer)malloc(sizeof(vkh_buffer_t));
     buff->pDev = pDev;
     VkBufferCreateInfo bufCreateInfo = {
         .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
@@ -21,27 +22,30 @@ void vkh_buffer_create(vkh_device *pDev, VkBufferUsageFlags usage, VkMemoryPrope
     buff->memoryPropertyFlags = memoryPropertyFlags;
 
     VK_CHECK_RESULT(vkh_buffer_bind(buff));
+    return buff;
 }
 
-void vkh_buffer_destroy(vkh_buffer* buff){
+void vkh_buffer_destroy(VkhBuffer buff){
     if (buff->buffer)
         vkDestroyBuffer(buff->pDev->vkDev, buff->buffer, NULL);
     if (buff->memory)
         vkFreeMemory(buff->pDev->vkDev, buff->memory, NULL);
+    free(buff);
+    buff = NULL;
 }
 
 
-VkResult vkh_buffer_map(vkh_buffer* buff){
+VkResult vkh_buffer_map(VkhBuffer buff){
     return vkMapMemory(buff->pDev->vkDev, buff->memory, 0, VK_WHOLE_SIZE, 0, &buff->mapped);
 }
-void vkh_buffer_unmap(vkh_buffer* buff){
+void vkh_buffer_unmap(VkhBuffer buff){
     if (!buff->mapped)
         return;
     vkUnmapMemory(buff->pDev->vkDev, buff->memory);
     buff->mapped = NULL;
 }
 
-VkResult vkh_buffer_bind(vkh_buffer* buff)
+VkResult vkh_buffer_bind(VkhBuffer buff)
 {
     return vkBindBufferMemory(buff->pDev->vkDev, buff->buffer, buff->memory, 0);
 }

diff --git a/vkh_buffer.h b/vkh_buffer.h
index 68aa1a1fadde60ad4c163e92b73cb7eca39ce1b4..33047447d3b9f5f4c96f08e9ad8fcca6fc71acf3 100644 (file)
--- a/vkh_buffer.h
+++ b/vkh_buffer.h
@@ -2,27 +2,19 @@
 #define VKH_BUFFER_H
 
 #include <vulkan/vulkan.h>
-#include "vkh_device.h"
+#include "vkhelpers.h"
 
-typedef struct vkh_buffer_t {
-       vkh_device* pDev;
-       VkBuffer buffer;
-       VkDeviceMemory memory;
-       VkDescriptorBufferInfo descriptor;
-       VkDeviceSize size;
-       VkDeviceSize alignment;
+typedef struct _vkh_buffer_t {
+    VkhDevice               pDev;
+    VkBuffer                buffer;
+    VkDeviceMemory          memory;
+    VkDescriptorBufferInfo  descriptor;
+    VkDeviceSize            size;
+    VkDeviceSize            alignment;
 
-       VkBufferUsageFlags usageFlags;
-       VkMemoryPropertyFlags memoryPropertyFlags;
-
-       void* mapped;
-}vkh_buffer;
-
-void vkh_buffer_create (vkh_device *pDev, VkBufferUsageFlags usage,
-               VkMemoryPropertyFlags memoryPropertyFlags, VkDeviceSize size, vkh_buffer* buff);
-void vkh_buffer_destroy (vkh_buffer* buff);
-VkResult vkh_buffer_map (vkh_buffer* buff);
-void vkh_buffer_unmap (vkh_buffer* buff);
-VkResult vkh_buffer_bind (vkh_buffer* buff);
+    VkBufferUsageFlags      usageFlags;
+    VkMemoryPropertyFlags   memoryPropertyFlags;
 
+    void*                   mapped;
+}vkh_buffer_t;
 #endif

diff --git a/vkh_device.h b/vkh_device.h
index cf36df3ebe4e045088516db19f7b8e1762a231c0..83ccdb165d0b8c602847aedad093cec198fdca4c 100644 (file)
--- a/vkh_device.h
+++ b/vkh_device.h
@@ -3,10 +3,10 @@
 
 #include "vkhelpers.h"
 
-typedef struct vkh_device_t{
-       VkDevice vkDev;
-       VkPhysicalDeviceMemoryProperties phyMemProps;
-       VkRenderPass renderPass;
-}vkh_device;
+typedef struct _vkh_device_t{
+    VkDevice vkDev;
+    VkPhysicalDeviceMemoryProperties phyMemProps;
+    VkRenderPass renderPass;
+}vkh_device_t;
 
 #endif

diff --git a/vkh_image.c b/vkh_image.c
index 1c1a8829486e329a6bd3fd3799c306d8f6287942..40fa6117f93980e0ab9c9e219c38ead050f3f4fb 100644 (file)
--- a/vkh_image.c
+++ b/vkh_image.c
@@ -1,11 +1,14 @@
 #include "vkh_image.h"
+#include "vkh_device.h"
 
-void _vkh_image_create (vkh_device *pDev, VkImageType imageType,
+VkhImage _vkh_image_create (VkhDevice pDev, VkImageType imageType,
                   VkFormat format, uint32_t width, uint32_t height,
                   VkMemoryPropertyFlags memprops, VkImageUsageFlags usage,
                   VkSampleCountFlagBits samples, VkImageTiling tiling,
                   uint32_t mipLevels, uint32_t arrayLayers,
-                  VkImageLayout layout, vkh_image* img){
+                  VkImageLayout layout){
+    VkhImage img = (VkhImage)malloc(sizeof(vkh_image_t));
+
     img->pDev = pDev;
     img->width = width;
     img->height = height;
@@ -34,30 +37,31 @@ void _vkh_image_create (vkh_device *pDev, VkImageType imageType,
     assert(memory_type_from_properties(&pDev->phyMemProps, memReq.memoryTypeBits, memprops,&memAllocInfo.memoryTypeIndex));
     VK_CHECK_RESULT(vkAllocateMemory(pDev->vkDev, &memAllocInfo, NULL, &img->memory));
     VK_CHECK_RESULT(vkBindImageMemory(pDev->vkDev, img->image, img->memory, 0));
+    return img;
 }
-void vkh_tex2d_array_create (vkh_device *pDev,
+VkhImage vkh_tex2d_array_create (VkhDevice pDev,
                              VkFormat format, uint32_t width, uint32_t height, uint32_t layers,
-                             VkMemoryPropertyFlags memprops, VkImageUsageFlags usage, VkImageLayout layout, vkh_image* img){
-    _vkh_image_create (pDev, VK_IMAGE_TYPE_2D, format, width, height, memprops,usage,
-        VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, 1, layers, layout, img);
+                             VkMemoryPropertyFlags memprops, VkImageUsageFlags usage, VkImageLayout layout){
+    return _vkh_image_create (pDev, VK_IMAGE_TYPE_2D, format, width, height, memprops,usage,
+        VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, 1, layers, layout);
 }
 
-void vkh_image_create (vkh_device *pDev,
+VkhImage vkh_image_create (VkhDevice pDev,
                            VkFormat format, uint32_t width, uint32_t height, VkImageTiling tiling,
                            VkMemoryPropertyFlags memprops,
-                           VkImageUsageFlags usage, VkImageLayout layout, vkh_image* img)
+                           VkImageUsageFlags usage, VkImageLayout layout)
 {
-    _vkh_image_create (pDev, VK_IMAGE_TYPE_2D, format, width, height, memprops,usage,
-                      VK_SAMPLE_COUNT_1_BIT, tiling, 1, 1, layout, img);
+    return _vkh_image_create (pDev, VK_IMAGE_TYPE_2D, format, width, height, memprops,usage,
+                      VK_SAMPLE_COUNT_1_BIT, tiling, 1, 1, layout);
 }
-void vkh_image_ms_create (vkh_device *pDev,
+VkhImage vkh_image_ms_create(VkhDevice pDev,
                            VkFormat format, VkSampleCountFlagBits num_samples, uint32_t width, uint32_t height,
                            VkMemoryPropertyFlags memprops,
-                           VkImageUsageFlags usage, VkImageLayout layout, vkh_image* img){
-    _vkh_image_create (pDev, VK_IMAGE_TYPE_2D, format, width, height, memprops,usage,
-                      num_samples, VK_IMAGE_TILING_OPTIMAL, 1, 1, layout, img);
+                           VkImageUsageFlags usage, VkImageLayout layout){
+   return  _vkh_image_create (pDev, VK_IMAGE_TYPE_2D, format, width, height, memprops,usage,
+                      num_samples, VK_IMAGE_TILING_OPTIMAL, 1, 1, layout);
 }
-void vkh_image_create_descriptor(vkh_image* img, VkImageViewType viewType, VkImageAspectFlags aspectFlags, VkFilter magFilter,
+void vkh_image_create_descriptor(VkhImage img, VkImageViewType viewType, VkImageAspectFlags aspectFlags, VkFilter magFilter,
                                  VkFilter minFilter, VkSamplerMipmapMode mipmapMode)
 {
     img->pDescriptor = (VkDescriptorImageInfo*)malloc(sizeof(VkDescriptorImageInfo));
@@ -78,7 +82,7 @@ void vkh_image_create_descriptor(vkh_image* img, VkImageViewType viewType, VkIma
     VK_CHECK_RESULT(vkCreateSampler(img->pDev->vkDev, &samplerCreateInfo, NULL, &img->pDescriptor->sampler));
 
 }
-void vkh_image_destroy(vkh_image* img)
+void vkh_image_destroy(VkhImage img)
 {
     if (img->pDescriptor != NULL){
         vkDestroyImageView(img->pDev->vkDev,img->pDescriptor->imageView,NULL);
@@ -88,4 +92,6 @@ void vkh_image_destroy(vkh_image* img)
     free(img->pDescriptor);
     vkDestroyImage(img->pDev->vkDev,img->image,NULL);
     vkFreeMemory(img->pDev->vkDev, img->memory, NULL);
+    free(img);
+    img = NULL;
 }

diff --git a/vkh_image.h b/vkh_image.h
index 42bd299afc69a6c831a7b23cff2c58c8e79e5da0..562f52db3fb2eedc1626fe1a075ce9bc2aef2025 100644 (file)
--- a/vkh_image.h
+++ b/vkh_image.h
@@ -2,27 +2,14 @@
 #define VKH_IMAGE_H
 
 #include "vkhelpers.h"
-#include "vkh_device.h"
 
-typedef struct vkh_image_t {
-    vkh_device*                                pDev;
+typedef struct _vkh_image_t {
+    VkhDevice                          pDev;
     VkImageCreateInfo          infos;
     uint32_t                           width, height;
     VkImage                                    image;
     VkDeviceMemory                     memory;
     VkDescriptorImageInfo*     pDescriptor;
     VkImageLayout           layout;//used for descriptor creation
-}vkh_image;
-
-void vkh_image_create          (vkh_device* pDev, VkFormat format, uint32_t width, uint32_t height, VkImageTiling tiling,
-                                VkMemoryPropertyFlags memprops,        VkImageUsageFlags usage, VkImageLayout layout, vkh_image *img);
-void vkh_image_ms_create       (vkh_device *pDev, VkFormat format, VkSampleCountFlagBits num_samples, uint32_t width, uint32_t height,
-                                VkMemoryPropertyFlags memprops,        VkImageUsageFlags usage, VkImageLayout layout, vkh_image *img);
-
-void vkh_tex2d_array_create (vkh_device *pDev, VkFormat format, uint32_t width, uint32_t height, uint32_t layers,
-                                VkMemoryPropertyFlags memprops, VkImageUsageFlags usage, VkImageLayout layout, vkh_image* img);
-
-void vkh_image_create_descriptor(vkh_image* img, VkImageViewType viewType, VkImageAspectFlags aspectFlags, VkFilter magFilter, VkFilter minFilter,
-                                 VkSamplerMipmapMode mipmapMode);
-void vkh_image_destroy(vkh_image* img);
+}vkh_image_t;
 #endif

diff --git a/vkhelpers.h b/vkhelpers.h
index d26a688cbea15917aabc216b70c4a13a1ad53432..c5a7f322857c2f5c40da966d7fecce4feb9a647e 100644 (file)
--- a/vkhelpers.h
+++ b/vkhelpers.h
@@ -22,14 +22,38 @@
     }                                                                                                                                                                                                  \
 }
 
+typedef struct _vkh_device_t*   VkhDevice;
+typedef struct _vkh_image_t*    VkhImage;
+typedef struct _vkh_buffer_t*   VkhBuffer;
+
+///////////////////////////////
+VkhImage vkh_image_create       (VkhDevice pDev, VkFormat format, uint32_t width, uint32_t height, VkImageTiling tiling,
+                                    VkMemoryPropertyFlags memprops,    VkImageUsageFlags usage, VkImageLayout layout);
+VkhImage vkh_image_ms_create    (VkhDevice pDev, VkFormat format, VkSampleCountFlagBits num_samples, uint32_t width, uint32_t height,
+                                    VkMemoryPropertyFlags memprops,    VkImageUsageFlags usage, VkImageLayout layout);
+VkhImage vkh_tex2d_array_create (VkhDevice pDev, VkFormat format, uint32_t width, uint32_t height, uint32_t layers,
+                                    VkMemoryPropertyFlags memprops, VkImageUsageFlags usage, VkImageLayout layout);
+void vkh_image_create_descriptor(VkhImage img, VkImageViewType viewType, VkImageAspectFlags aspectFlags, VkFilter magFilter, VkFilter minFilter,
+                                    VkSamplerMipmapMode mipmapMode);
+void vkh_image_destroy          (VkhImage img);
+
+////////////////////////////////
+VkhBuffer   vkh_buffer_create   (VkhDevice pDev, VkBufferUsageFlags usage,
+                                    VkMemoryPropertyFlags memoryPropertyFlags, VkDeviceSize size);
+void        vkh_buffer_destroy  (VkhBuffer buff);
+VkResult    vkh_buffer_map      (VkhBuffer buff);
+void        vkh_buffer_unmap    (VkhBuffer buff);
+VkResult    vkh_buffer_bind     (VkhBuffer buff);
+///////////////////////////////
 VkPhysicalDevice vkh_find_phy (VkInstance inst, VkPhysicalDeviceType phyType);
 VkFence vkh_fence_create (VkDevice dev);
 VkSemaphore vkh_semaphore_create (VkDevice dev);
 VkCommandPool vkh_cmd_pool_create (VkDevice dev, uint32_t qFamIndex, VkCommandPoolCreateFlags flags);
 VkCommandBuffer vkh_cmd_buff_create (VkDevice dev, VkCommandPool cmdPool, VkCommandBufferLevel level);
-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_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);
 void vkcrow_cmd_copy_submit(VkQueue queue, VkCommandBuffer *pCmdBuff, VkSemaphore* pWaitSemaphore, VkSemaphore* pSignalSemaphore);