DesktopBackend.hpp

/*
** ETIB PROJECT, 2026
** evan
** File description:
** DesktopBackend
*/
 
#pragma once
 
#include "evan/EvanPlatform.hpp"
 
#include "evan/ADeviceBackend.hpp"
#include "IDesktopPlatform.hpp"
#include "evan/ASwapchainImage.hpp"
 
#include "evan/Version.hpp"
 
#include <utility/event/keyboard_event.hpp>
#include <utility/event/mouse_button_event.hpp>
 
const std::vector<const char *> deviceExtensions = {
    VK_KHR_SWAPCHAIN_EXTENSION_NAME
};
 
namespace evan
{
    struct SwapChainSupportDetails {
        VkSurfaceCapabilitiesKHR capabilities;
 
        std::vector<VkSurfaceFormatKHR> formats;
 
        std::vector<VkPresentModeKHR> presentModes;
    };
 
    class DesktopBackend: public ADeviceBackend
    {
        public:
        DesktopBackend(const IPlatform &platform);
 
        ~DesktopBackend();
 
        Error preprocessFrame(ASwapchainContext &swapchainContext) override
        {
            // No specific preprocessing needed for Desktop backend
            return Error::Ok;
        }
 
        Error processFrame(VkPresentInfoKHR presentInfo,
                           ASwapchainImage &swapchainImage) override;
 
        Error postprocessFrame(ASwapchainContext &swapchainContext) override
        {
            // No specific postprocessing needed for Desktop backend
            return Error::Ok;
        }
 
        uint32_t countSwapchainFormats() const override;
 
        std::vector<int64_t> enumerateSwapchainFormats(
            uint32_t swapchainFormatCount) const override;
 
        QueueFamilyIndices findQueueFamilies() override;
 
        evan::SwapChainSupportDetails querySwapChainSupport();
 
        void createPresentQueue();
 
        VkSurfaceKHR getSurface() const
        {
            return _surface;
        }
 
        protected:
        void createInstance(const IPlatform &platform,
                            const std::string &appName,
                            Version &appVersion) override;
 
        void createLogicalDevice() override;
 
        void pickPhysicalDevice() override;
 
        private:
        VkSurfaceKHR _surface = VK_NULL_HANDLE;
 
        VkQueue _presentQueue = VK_NULL_HANDLE;
 
        const IPlatform *_platform = nullptr;
 
        bool isDeviceSuitable(VkPhysicalDevice physicalDevice,
                              std::vector<const char *> deviceExtensions);
 
        bool checkDeviceExtensionSupport(
            VkPhysicalDevice device,
            std::vector<const char *> deviceExtensions);
 
        bool checkValidationLayerSupport();
 
        void populateDebugMessengerCreateInfo(
            VkDebugUtilsMessengerCreateInfoEXT &createInfo,
            debugCallback_t debugCallback);
 
        void setupCallbackEvent(const IPlatform &platform);
    };
}    // namespace evan