adding Vulkan's buffer creation

Sources/Backends/Vulkan/VulkanBuffer.c

@@ -0,0 +1,62 @@
+// Copyright (C) 2024 kanel
+// This file is part of "Pulse"
+// For conditions of distribution and use, see copyright notice in LICENSE
+
+#include "Pulse.h"
+#include "Vulkan.h"
+#include "VulkanBuffer.h"
+#include "VulkanDevice.h"
+
+PulseBuffer VulkanCreateBuffer(PulseDevice device, const PulseBufferCreateInfo* create_infos)
+{
+	VulkanDevice* vulkan_device = VULKAN_RETRIEVE_DRIVER_DATA_AS(device, VulkanDevice*);
+
+	PulseBufferHandler* buffer = (PulseBufferHandler*)calloc(1, sizeof(PulseBufferHandler));
+	PULSE_CHECK_ALLOCATION_RETVAL(buffer, PULSE_NULL_HANDLE);
+
+	VulkanBuffer* vulkan_buffer = (VulkanBuffer*)calloc(1, sizeof(VulkanBuffer));
+	PULSE_CHECK_ALLOCATION_RETVAL(vulkan_buffer, PULSE_NULL_HANDLE);
+
+	buffer->device = device;
+	buffer->driver_data = vulkan_buffer;
+	buffer->size = create_infos->size;
+	buffer->usage = create_infos->usage;
+
+	if(buffer->usage & PULSE_BUFFER_USAGE_TRANSFER_UPLOAD)
+	{
+		vulkan_buffer->usage |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
+	}
+	if(buffer->usage & PULSE_BUFFER_USAGE_TRANSFER_DOWNLOAD)
+	{
+		vulkan_buffer->usage |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+	}
+	if(buffer->usage & PULSE_BUFFER_USAGE_STORAGE_READ || buffer->usage & PULSE_BUFFER_USAGE_STORAGE_WRITE)
+	{
+		vulkan_buffer->usage |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
+	}
+	if(buffer->usage & PULSE_BUFFER_USAGE_UNIFORM_ACCESS)
+	{
+		vulkan_buffer->usage |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
+	}
+
+	VmaAllocationCreateInfo allocation_create_info = { 0 };
+	allocation_create_info.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT;
+	allocation_create_info.usage = VMA_MEMORY_USAGE_AUTO;
+
+	VkBufferCreateInfo buffer_create_info = { 0 };
+	buffer_create_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+	buffer_create_info.size = buffer->size;
+	buffer_create_info.usage = vulkan_buffer->usage;
+	buffer_create_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+
+	CHECK_VK_RETVAL(device->backend, vmaCreateBuffer(vulkan_device->allocator, &buffer_create_info, &allocation_create_info, &vulkan_buffer->buffer, &vulkan_buffer->allocation, PULSE_NULLPTR), PULSE_ERROR_INITIALIZATION_FAILED, PULSE_NULL_HANDLE);
+
+	return buffer;
+}
+
+void VulkanDestroyBuffer(PulseDevice device, PulseBuffer buffer)
+{
+	VulkanDevice* vulkan_device = VULKAN_RETRIEVE_DRIVER_DATA_AS(device, VulkanDevice*);
+	VulkanBuffer* vulkan_buffer = VULKAN_RETRIEVE_DRIVER_DATA_AS(buffer, VulkanBuffer*);
+	vmaDestroyBuffer(vulkan_device->allocator, vulkan_buffer->buffer, vulkan_buffer->allocation);
+}

Sources/Backends/Vulkan/VulkanBuffer.h

@@ -0,0 +1,29 @@
+// Copyright (C) 2024 kanel
+// This file is part of "Pulse"
+// For conditions of distribution and use, see copyright notice in LICENSE
+
+#ifdef PULSE_ENABLE_VULKAN_BACKEND
+
+#ifndef PULSE_VULKAN_BUFFER_H_
+#define PULSE_VULKAN_BUFFER_H_
+
+#include <vulkan/vulkan_core.h>
+#include <vk_mem_alloc.h>
+
+#include <Pulse.h>
+#include "../../PulseInternal.h"
+#include "VulkanEnums.h"
+
+typedef struct VulkanBuffer
+{
+	VkBuffer buffer;
+	VkBufferUsageFlags usage;
+	VmaAllocation allocation;
+} VulkanBuffer;
+
+PulseBuffer VulkanCreateBuffer(PulseDevice device, const PulseBufferCreateInfo* create_infos);
+void VulkanDestroyBuffer(PulseDevice device, PulseBuffer buffer);
+
+#endif // PULSE_VULKAN_BUFFER_H_
+
+#endif // PULSE_ENABLE_VULKAN_BACKEND

Sources/Backends/Vulkan/VulkanDevice.c

@@ -11,6 +11,7 @@
 #include "VulkanInstance.h"
 #include "VulkanLoader.h"
 #include "VulkanQueue.h"
+#include "VulkanBuffer.h"
 #include "../../PulseInternal.h"
 
 #include <string.h>

Sources/PulseBuffer.c

@@ -0,0 +1,34 @@
+// Copyright (C) 2024 kanel
+// This file is part of "Pulse"
+// For conditions of distribution and use, see copyright notice in LICENSE
+
+#include "Pulse.h"
+#include "PulseInternal.h"
+
+PULSE_API PulseBuffer PulseCreateBuffer(PulseDevice device, const PulseBufferCreateInfo* create_infos)
+{
+	PULSE_CHECK_HANDLE_RETVAL(device, PULSE_NULL_HANDLE);
+	if(PULSE_IS_BACKEND_LOW_LEVEL_DEBUG(device->backend))
+	{
+		if(create_infos == PULSE_NULLPTR)
+		{
+			PulseLogError(device->backend, "create_infos is NULL");
+			PulseSetInternalError(PULSE_ERROR_INITIALIZATION_FAILED);
+			return PULSE_NULL_HANDLE;
+		}
+	}
+	return device->PFN_CreateBuffer(device, create_infos);
+}
+
+PULSE_API void PulseDestroyBuffer(PulseDevice device, PulseBuffer buffer)
+{
+	PULSE_CHECK_HANDLE(device);
+
+	if(buffer == PULSE_NULL_HANDLE)
+	{
+		if(PULSE_IS_BACKEND_LOW_LEVEL_DEBUG(device->backend))
+			PulseLogWarning(device->backend, "buffer is NULL, this may be a bug in your application");
+		return;
+	}
+	return device->PFN_DestroyBuffer(device, buffer);
+}

Sources/PulseDefs.h

@@ -62,5 +62,7 @@
 	PULSE_LOAD_DRIVER_DEVICE_FUNCTION(RequestCommandList, _namespace) \
 	PULSE_LOAD_DRIVER_DEVICE_FUNCTION(SubmitCommandList, _namespace) \
 	PULSE_LOAD_DRIVER_DEVICE_FUNCTION(ReleaseCommandList, _namespace) \
+	PULSE_LOAD_DRIVER_DEVICE_FUNCTION(CreateBuffer, _namespace) \
+	PULSE_LOAD_DRIVER_DEVICE_FUNCTION(DestroyBuffer, _namespace) \
 
 #endif // PULSE_DEFS_H_

Sources/PulseInternal.h

@@ -30,7 +30,10 @@ typedef struct PulseBackendHandler
 
 typedef struct PulseBufferHandler
 {
+	PulseDevice device;
 	void* driver_data;
+	PulseBufferUsageFlags usage;
+	PulseDeviceSize size;
 } PulseBufferHandler;
 
 typedef struct PulseCommandListHandler
@@ -66,6 +69,8 @@ typedef struct PulseDeviceHandler
 	PulseRequestCommandListPFN PFN_RequestCommandList;
 	PulseSubmitCommandListPFN PFN_SubmitCommandList;
 	PulseReleaseCommandListPFN PFN_ReleaseCommandList;
+	PulseCreateBufferPFN PFN_CreateBuffer;
+	PulseDestroyBufferPFN PFN_DestroyBuffer;
 
 	// Attributes
 	void* driver_data;

Sources/PulsePFNs.h

@@ -24,5 +24,7 @@ typedef bool (*PulseWaitForFencesPFN)(PulseDevice, const PulseFence*, uint32_t,
 typedef PulseCommandList (*PulseRequestCommandListPFN)(PulseDevice, PulseCommandListUsage);
 typedef bool (*PulseSubmitCommandListPFN)(PulseDevice, PulseCommandList, PulseFence);
 typedef void (*PulseReleaseCommandListPFN)(PulseDevice, PulseCommandList);
+typedef PulseBuffer (*PulseCreateBufferPFN)(PulseDevice, const PulseBufferCreateInfo*);
+typedef void (*PulseDestroyBufferPFN)(PulseDevice, PulseBuffer);
 
 #endif // PULSE_PFNS_H_