ASwapchainContext.hpp

/*
** ETIB PROJECT, 2026
** evan
** File description:
** ASwapchainContext
*/
 
#pragma once
 
#include "evan/EvanPlatform.hpp"
#include "evan/ADeviceBackend.hpp"
#include "evan/ASwapchainImage.hpp"
#include "evan/RenderSettings.hpp"
#include "evan/ViewSet.hpp"
 
#include <utility/graphic/view.hpp>
 
#include <utility/logging/loggable.hpp>
#include <utility/logging/default_logger.hpp>
 
#include <map>
#include <memory>
#include <iostream>
 
namespace evan
{
 
    class ASwapchainContext:
        protected utility::logging::Loggable<ASwapchainContext,
                                             utility::logging::DefaultLogger>
    {
        public:
        virtual ~ASwapchainContext() = default;
 
        struct SwapChainSupportDetails {
            VkSurfaceCapabilitiesKHR capabilities;
 
            std::vector<VkSurfaceFormatKHR> formats;
 
            std::vector<VkPresentModeKHR> presentModes;
        };
 
        virtual void destroy(VkDevice device) = 0;
 
        virtual void recreateSwapchain(const DeviceContext &deviceContext,
                                       VkRenderPass renderpass) = 0;
 
        VkRenderPass getRenderPass() const;
 
        virtual VkSampleCountFlagBits getMsaaSamples() const = 0;
 
        virtual VkResult aquireImage(uint32_t index, VkDevice device,
                                     VkSemaphore imageAvailableSemaphore,
                                     VkFence inFlightFence,
                                     uint32_t &imageIndex) = 0;
 
        virtual void waitForImage(uint32_t index) = 0;
 
        std::vector<std::shared_ptr<ASwapchainImage>> _swapchainImages;
 
        virtual ViewSet &getViewSet() = 0;
 
        virtual const ViewSet &getViewSet() const = 0;
 
        std::size_t getSwapchainCount() const;
 
        virtual bool usesImageAvailableSemaphore() const;
 
        virtual bool needsSwapchainRecreation() const;
 
        virtual bool usesMultiview() const;
 
        utility::graphic::ViewF getView(std::size_t index) const;
 
        virtual void setView(std::size_t index,
                             const utility::graphic::ViewF &view);
 
        const utility::graphic::PoseF &getViewOffset(void) const;
 
        std::size_t getViewCount(void) const;
 
        glm::mat4 getProjection(std::size_t index) const;
 
        utility::math::Vector2F getViewportSize() const;
 
        static void updateViewForExtent(utility::graphic::ViewF &view,
                                        VkExtent2D extent);
 
        protected:
        VkRenderPass _renderPass;
 
        utility::graphic::PoseF _viewOffset {};
 
        void createRenderPass(
            const std::shared_ptr<ADeviceBackend> &deviceBackend,
            VkSampleCountFlagBits msaaSamples, ColorAttachmentMode mode,
            uint32_t viewMask = 0);
 
        VkFormat
            selectSwapchainFormat(VkPhysicalDevice physicalDevice,
                                  const std::vector<int64_t> &swapchainFormats);
 
        VkFormat findSupportedFormat(VkPhysicalDevice physicalDevice,
                                     const std::vector<VkFormat> &candidates,
                                     VkImageTiling tiling,
                                     VkFormatFeatureFlags features);
 
        private:
        static bool isPlausibleVkFormat(int64_t value);
 
        static bool supportsColorAttachment(VkPhysicalDevice physicalDevice,
                                            VkFormat format);
 
        static VkFormat
            fallbackSwapchainFormat(VkPhysicalDevice physicalDevice);
    };
}    // namespace evan