ADeviceBackend.hpp

/*
** ETIB PROJECT, 2026
** evan
** File description:
** ADeviceBackend
*/
 
#pragma once
 
#include "evan/EvanPlatform.hpp"
#include "evan/Error.hpp"
#include "evan/Version.hpp"
 
#include "evan/IPlatform.hpp"
#include "evan/QueueFamilyIndices.hpp"
 
#include <utility/logging/loggable.hpp>
#include <utility/logging/default_logger.hpp>
 
#include <set>
#include <iostream>
 
namespace evan
{
    class ASwapchainContext;
    class ASwapchainImage;
 
    class ADeviceBackend:
        protected utility::logging::Loggable<ADeviceBackend,
                                             utility::logging::DefaultLogger>
    {
        public:
        struct CopyBufferProperties {
            VkDevice _logicalDevice;
            VkCommandPool _commandPool;
            VkQueue _graphicsQueue;
            VkBuffer _srcBuffer;
            VkBuffer _dstBuffer;
            VkDeviceSize _size;
        };
 
        struct CopyBufferToImageProperties {
            VkCommandPool _commandPool;
            VkQueue _graphicsQueue;
            VkBuffer _buffer;
            VkImage _image;
            uint32_t _width;
            uint32_t _height;
        };
 
        struct TransitionImageLayoutProperties {
            VkCommandPool _commandPool;
            VkQueue _graphicsQueue;
            VkImage _image;
            VkFormat _format;
            VkImageLayout _oldLayout;
            VkImageLayout _newLayout;
            uint32_t _mipLevels;
        };
 
        struct CreateImageProperties {
            uint32_t _width;
            uint32_t _height;
            uint32_t _mipLevels;
            VkSampleCountFlagBits _numSamples;
            VkFormat _format;
            VkImageTiling _tiling;
            VkImageUsageFlags _usage;
            VkMemoryPropertyFlags _properties;
            VkImage &_image;
            VkDeviceMemory &_imageMemory;
            uint32_t _arrayLayers = 1;
        };
 
        struct CreateBufferProperties {
            VkDeviceSize _size;
            VkBufferUsageFlags _usage;
            VkMemoryPropertyFlags _properties;
            VkBuffer &_buffer;
            VkDeviceMemory &_bufferMemory;
        };
 
        virtual ~ADeviceBackend();
 
        virtual uint32_t countSwapchainFormats() const = 0;
 
        virtual std::vector<int64_t>
            enumerateSwapchainFormats(uint32_t swapchainFormatCount) const = 0;
 
        virtual evan::QueueFamilyIndices findQueueFamilies() = 0;
 
        virtual Error preprocessFrame(ASwapchainContext &swapchainContext) = 0;
 
        virtual Error processFrame(VkPresentInfoKHR presentInfo,
                                   ASwapchainImage &swapchainImage) = 0;
 
        virtual Error postprocessFrame(ASwapchainContext &swapchainContext) = 0;
 
        Error createBuffer(const CreateBufferProperties &properties) const;
 
        Error transitionImageLayout(
            const TransitionImageLayoutProperties &properties) const;
 
        VkCommandBuffer
            beginSingleTimeCommands(VkCommandPool commandPool) const;
 
        void endSingleTimeCommands(VkCommandPool commandPool,
                                   VkQueue graphicsQueue,
                                   VkCommandBuffer commandBuffer) const;
 
        Error createImage(const CreateImageProperties &properties) const;
 
        Error copyBufferToImage(
            const CopyBufferToImageProperties &properties) const;
 
        Error copyBuffer(const CopyBufferProperties &properties) const;
 
        Result<VkImageView> createImageView(VkImage image, VkFormat format,
                                            VkImageAspectFlags aspectFlags,
                                            uint32_t mipLevels,
                                            uint32_t layerCount = 1) const;
 
        virtual VkDevice getDevice() const
        {
            return _device;
        }
 
        virtual VkInstance getInstance() const
        {
            return _VkInstance;
        }
 
        virtual VkPhysicalDevice getPhysicalDevice() const
        {
            return _physicalDevice;
        }
 
        bool supportsMultiview() const
        {
            return _multiviewSupported;
        }
 
        [[nodiscard]] bool supportsTimestampQueries();
 
        [[nodiscard]] float getTimestampPeriod() const;
 
        [[nodiscard]] uint32_t getTimestampValidBits();
 
        protected:
        VkPhysicalDevice _physicalDevice = VK_NULL_HANDLE;
 
        VkDevice _device = VK_NULL_HANDLE;
 
        VkInstance _VkInstance = VK_NULL_HANDLE;
 
        bool _multiviewSupported = false;
 
        virtual void createInstance(const IPlatform &platform,
                                    const std::string &appName,
                                    Version &appVersion) = 0;
 
        virtual void createLogicalDevice() = 0;
 
        virtual void pickPhysicalDevice() = 0;
 
        static bool queryMultiviewSupport(VkPhysicalDevice physicalDevice,
                                          uint32_t apiVersion);
 
        std::vector<VkLayerProperties> getAvailableLayers();
 
        private:
        bool hasStencilComponent(VkFormat format) const;
 
        Result<uint32_t> findMemoryType(uint32_t typeFilter,
                                        VkMemoryPropertyFlags properties) const;
    };
}    // namespace evan