Feature/add vulkan device

src/runtime/CMakeLists.txt

@@ -19,6 +19,11 @@ SET(segfault_renderer_src
     renderer/RHIVulkan.cpp
     renderer/vulkanbuffer.cpp
     renderer/vulkanbuffer.h
+    renderer/vulkandevice.cpp
+    renderer/vulkandevice.h
+    renderer/vulkanutils.cpp
+    renderer/vulkanutils.h
+    renderer/vulkantypes.h
 )
 
 SET(segfault_application_src

src/runtime/core/genericfilemanager.h

@@ -4,14 +4,39 @@
 
 namespace segfault::core {
 
+    /// @class GenericFileManager
+    /// @brief A generic file manager implementation.
     class SEGFAULT_EXPORT GenericFileManager final : public IFileManager {
     public:
+        /// @brief Constructs a new instance of GenericFileManager.
         GenericFileManager() = default;
+
+        /// @brief Destroys the GenericFileManager instance.
         ~GenericFileManager() final = default;
+
+        /// @brief Creates a file reader for the specified file.
+        /// @param name The name of the file to read.
+        /// @return A pointer to the created file reader, or nullptr if creation failed.
         FileArchive *createFileReader(const char *name) final;
+
+        /// @brief Creates a file writer for the specified file.
+        /// @param name The name of the file to write.
+        /// @return A pointer to the created file writer, or nullptr if creation failed.
         FileArchive *createFileWriter(const char *name) final;
+
+        /// @brief Closes the specified file archive.
+        /// @param archive The file archive to close.
         void close(FileArchive *archive) final;
+
+        /// @brief Checks if a file exists.
+        /// @param name The name of the file to check.
+        /// @return True if the file exists, false otherwise.
         bool exist(const char* name) final;
+        /// @brief Gets statistics for the specified archive.
+
+        /// @param name The name of the archive.
+        /// @param stat The structure to store the statistics in.
+        /// @return True if statistics were successfully retrieved, false otherwise.
         bool getArchiveStat(const char *name, FileStat &stat) final;
     };
 

src/runtime/renderer/vulkanbuffer.cpp

@@ -1,6 +1,8 @@
 #include "vulkanbuffer.h"
 #include <memory>
 #include <cassert>
+#include <string.h>
+
 namespace segfault::renderer {
 
     uint32_t findMemoryType(VkPhysicalDevice physicalDevice, uint32_t typeFilter, VkMemoryPropertyFlags properties) {
@@ -58,7 +60,7 @@ namespace segfault::renderer {
         if (vkAllocateMemory(mDevice, &allocInfo, nullptr, &mMemory) != VK_SUCCESS) {
             return false;
         }
-        
+
         return true;
     }
 
@@ -95,7 +97,7 @@ namespace segfault::renderer {
         assert(mMapped != nullptr && "Buffer must be mapped before copying data to it.");
         assert(size <= VK_WHOLE_SIZE && "Size must be less than or equal to VK_WHOLE_SIZE.");
         assert(size <= 0 || data != nullptr && "Data pointer must not be null when size is greater than 0.");
-        
+
         if (mMapped != nullptr) {
             memcpy(mMapped, data, static_cast<size_t>(size));
         }

src/runtime/renderer/vulkanbuffer.h

@@ -2,15 +2,10 @@
 
 #include "volk.h"
 
+#include "vulkantypes.h"
 
 namespace segfault::renderer {
 
-    enum class BufferUsage : uint32_t {
-        VertexBuffer = 0x1,
-        IndexBuffer = 0x2,
-        UniformBuffer = 0x4
-    };
-
     class VulkanBuffer {
     public:
         VulkanBuffer(VkPhysicalDevice physicalDevice, VkDevice device);
@@ -26,13 +21,15 @@ namespace segfault::renderer {
         void copyTo(void *data, VkDeviceSize size);
         VkBuffer getBuffer() const { return mBuffer; }
         VkDeviceMemory getMemory() const { return mMemory; }
+		size_t getSize() const { return mSize; }
 
     private:
         VkPhysicalDevice mPhysicalDevice{};
         VkDevice mDevice{};
         VkBuffer mBuffer{};
         VkDeviceMemory mMemory{};
         void *mMapped{nullptr};
+        size_t mSize{0};
     };
 
 } // namespace segfault::renderer

src/runtime/renderer/vulkandevice.cpp

@@ -0,0 +1,92 @@
+#include "vulkandevice.h"
+
+namespace segfault::renderer {
+
+    bool QueueFamilyIndices::isGraphicsComplete() const {
+        return graphicsFamily.has_value() && presentFamily.has_value();
+    }
+
+    VulkanDevice::VulkanDevice(VkPhysicalDevice physicalDevice) : mPhysicalDevice(physicalDevice) {
+        // empty
+    }
+
+    VulkanDevice::~VulkanDevice() {
+        shutdown();
+    }
+
+    bool VulkanDevice::init(VkSurfaceKHR surface, const DeviceRequirements& requirements) {
+		if (mDevice != VK_NULL_HANDLE) {
+			return true; // Already initialized
+		}
+
+        mSurface = surface;
+
+        return true;
+    }
+
+    void VulkanDevice::shutdown() {
+        if (mDevice == VK_NULL_HANDLE) {
+            return;
+        }
+
+        vkDestroyDevice(mDevice, nullptr);
+        mDevice = VK_NULL_HANDLE;
+		mSurface = VK_NULL_HANDLE;
+    }
+
+    VulkanBuffer* VulkanDevice::createBuffer(size_t size, BufferUsage usageFlags, uint32_t memoryPropertyFlags) {
+		VulkanBuffer* buffer = new VulkanBuffer(mPhysicalDevice, mDevice);
+		if (!buffer->init(size, usageFlags, memoryPropertyFlags)) {
+			delete buffer;
+			return nullptr;
+		}
+		return buffer;
+    }
+
+    bool VulkanDevice::copyBuffer(VulkanBuffer* source, VulkanBuffer* destination, VkDeviceSize size, VkQueue queue, VkCommandPool pool) {
+		if (!source || !destination) {
+			return false;
+		}
+
+		VkCommandBuffer copyCmd = createCommandBuffer(pool);
+		VkBufferCopy bufferCopy{};
+		if (size == 0)
+		{
+			bufferCopy.size = source->getSize();
+		}
+		else
+		{
+			bufferCopy.size = size;
+		}
+
+		vkCmdCopyBuffer(copyCmd, source->getBuffer(), destination->getBuffer(), 1, &bufferCopy);
+
+		flushCommandBuffer(copyCmd, queue, pool, true);
+	}
+
+	VkCommandBuffer VulkanDevice::createCommandBuffer(VkCommandPool commandPool, VkCommandBufferLevel level) {
+		VkCommandBufferAllocateInfo allocInfo{};
+		allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+		allocInfo.commandPool = commandPool;
+		allocInfo.level = level;
+		allocInfo.commandBufferCount = 1;
+
+		VkCommandBuffer commandBuffer;
+
+		vkAllocateCommandBuffers(mDevice, &allocInfo, &commandBuffer);
+		return commandBuffer;
+    }
+
+
+	void VulkanDevice::flushCommandBuffer(VkCommandBuffer commandBuffer, VkQueue queue, VkCommandPool pool, bool free) {
+		VkSubmitInfo submitInfo{};
+		submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+		submitInfo.commandBufferCount = 1;
+		submitInfo.pCommandBuffers = &commandBuffer;
+		vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
+		if (free) {
+			vkFreeCommandBuffers(mDevice, pool, 1, &commandBuffer);
+		}
+	}
+
+} // namespace segfault::renderer

src/runtime/renderer/vulkandevice.h

@@ -0,0 +1,95 @@
+#pragma once
+
+#include "volk.h"
+#include "core/segfault.h"
+#include <vector>
+#include <optional>
+#include <string>
+#include <cstdint>
+#include "vulkantypes.h"
+#include "vulkanbuffer.h"
+
+namespace segfault::renderer {
+
+    struct QueueFamilyIndices {
+        std::optional<uint32_t> graphicsFamily;
+        std::optional<uint32_t> presentFamily;
+        std::optional<uint32_t> computeFamily;
+        std::optional<uint32_t> transferFamily;
+
+        bool isComplete() const;
+        bool isGraphicsComplete() const;
+    };
+
+    struct DeviceRequirements {
+        std::vector<const char*> requiredExtensions;
+        std::vector<const char*> optionalExtensions;
+        VkPhysicalDeviceFeatures requiredFeatures{};
+        VkPhysicalDeviceFeatures optionalFeatures{};
+        bool requirePresentQueue{ false };
+        bool requireComputeQueue{ false };
+        bool requireTransferQueue{ false };
+    };
+
+    struct DeviceProperties {
+        VkPhysicalDeviceProperties properties{};
+        VkPhysicalDeviceFeatures features{};
+        VkPhysicalDeviceMemoryProperties memoryProperties{};
+        std::vector<VkExtensionProperties> availableExtensions;
+        std::vector<VkQueueFamilyProperties> queueFamilies;
+    };
+
+    //---------------------------------------------------------------------------------------------
+    /// @class VulkanDevice
+    /// @brief Encapsulates a Vulkan physical and logical device with queue management.
+    ///
+    /// This class manages the selection, creation, and lifecycle of Vulkan devices.
+    /// It provides access to device properties, features, queues, and memory management.
+    //---------------------------------------------------------------------------------------------
+    class SEGFAULT_EXPORT VulkanDevice final {
+    public:
+        // Disallow copying
+        VulkanDevice(const VulkanDevice&) = delete;
+        VulkanDevice& operator=(const VulkanDevice&) = delete;
+
+        /// @brief Constructs a VulkanDevice.
+        /// @param instance The Vulkan instance.
+        VulkanDevice(VkPhysicalDevice physicalDevice);
+
+		/// @brief The class destructor. Ensures that all Vulkan resources are properly released.
+        ~VulkanDevice();
+
+        /// @brief Initializes the device with the given surface and requirements.
+        /// @param surface The presentation surface (can be VK_NULL_HANDLE for headless).
+        /// @param requirements Device feature and extension requirements.
+        /// @return True if device initialization succeeded.
+        bool init(VkSurfaceKHR surface, const DeviceRequirements& requirements = {});
+
+        /// @brief Shuts down the device and releases all resources.
+        void shutdown();
+
+        // Accessors
+        VkPhysicalDevice getPhysicalDevice() const { return mPhysicalDevice; }
+        VkDevice getDevice() const { return mDevice; }
+        VkQueue getGraphicsQueue() const { return mGraphicsQueue; }
+        VkQueue getPresentQueue() const { return mPresentQueue; }
+        const QueueFamilyIndices& getQueueFamilyIndices() const { return mQueueFamilyIndices; }
+        uint32_t getGraphicsQueueFamilyIndex() const;
+        uint32_t getPresentQueueFamilyIndex() const;
+        const DeviceProperties& getProperties() const { return mProperties; }
+		VulkanBuffer* createBuffer(size_t size, BufferUsage usageFlags, uint32_t memoryPropertyFlags);
+        bool copyBuffer(VulkanBuffer *source, VulkanBuffer *destination, VkDeviceSize size, VkQueue queue, VkCommandPool pool);
+        VkCommandBuffer createCommandBuffer(VkCommandPool commandPool, VkCommandBufferLevel level = VK_COMMAND_BUFFER_LEVEL_PRIMARY);
+        void flushCommandBuffer(VkCommandBuffer commandBuffer, VkQueue queue, VkCommandPool pool, bool free);
+
+    private:
+        VkPhysicalDevice mPhysicalDevice{};
+        VkDevice mDevice{};
+        VkQueue mGraphicsQueue{};
+        VkQueue mPresentQueue{};
+        QueueFamilyIndices mQueueFamilyIndices{};
+        DeviceProperties mProperties{};
+        VkSurfaceKHR mSurface{};
+    };
+
+} // namespace segfault::renderer

src/runtime/renderer/vulkantypes.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <cstdint>
+
+namespace segfault::renderer {
+
+    enum class BufferUsage : uint32_t {
+        VertexBuffer = 0x1,
+        IndexBuffer = 0x2,
+        UniformBuffer = 0x4
+    };
+
+} // namespace segfault::renderer

src/runtime/renderer/vulkanutils.cpp

@@ -0,0 +1,65 @@
+#include "vulkanutils.h"
+#include "core/segfaultexception.h"
+#include "volk.h"
+
+#include <array>
+
+namespace segfault::renderer {
+
+    using namespace segfault::core;
+
+        std::array<VkVertexInputAttributeDescription, 3> Vertex::getAttributeDescriptions() {
+            std::array<VkVertexInputAttributeDescription, 3> attributeDescriptions{};
+
+            attributeDescriptions[0].binding = 0;
+            attributeDescriptions[0].location = 0;
+            attributeDescriptions[0].format = VK_FORMAT_R32G32B32_SFLOAT;
+            attributeDescriptions[0].offset = offsetof(Vertex, pos);
+
+            attributeDescriptions[1].binding = 0;
+            attributeDescriptions[1].location = 1;
+            attributeDescriptions[1].format = VK_FORMAT_R32G32B32_SFLOAT;
+            attributeDescriptions[1].offset = offsetof(Vertex, color);
+
+            attributeDescriptions[2].binding = 0;
+            attributeDescriptions[2].location = 2;
+            attributeDescriptions[2].format = VK_FORMAT_R32G32_SFLOAT;
+            attributeDescriptions[2].offset = offsetof(Vertex, texCoord);
+
+            return attributeDescriptions;
+        }
+
+        VkVertexInputBindingDescription Vertex::getBindingDescription() {
+            VkVertexInputBindingDescription bindingDescription{};
+
+            bindingDescription.binding = 0;
+            bindingDescription.stride = sizeof(Vertex);
+            bindingDescription.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
+
+            return bindingDescription;
+        }
+
+    VkFormat VulkanUtils::findSupportedFormat(VkPhysicalDevice &physicalDevice, const std::vector<VkFormat>& candidates, VkImageTiling tiling, VkFormatFeatureFlags features) {
+        for (VkFormat format : candidates) {
+            VkFormatProperties props;
+            vkGetPhysicalDeviceFormatProperties(physicalDevice, format, &props);
+            if (tiling == VK_IMAGE_TILING_LINEAR && (props.linearTilingFeatures & features) == features) {
+                return format;
+            } else if (tiling == VK_IMAGE_TILING_OPTIMAL && (props.optimalTilingFeatures & features) == features) {
+                return format;
+            }
+        }
+
+        throw SegfaultException("failed to find supported format!");
+    }
+
+    VkFormat VulkanUtils::findDepthFormat(VkPhysicalDevice &physicalDevice) {
+        return findSupportedFormat(
+			physicalDevice,
+            { VK_FORMAT_D32_SFLOAT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT },
+            VK_IMAGE_TILING_OPTIMAL,
+            VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT
+        );
+    }
+
+}