XrSwapchainContext.hpp

/*
** ETIB PROJECT, 2026
** evan
** File description:
** XrSwapchainContext
*/
 
#pragma once
 
#include "evan/ASwapchainContext.hpp"
#include "evan/ASwapchainImage.hpp"
#include "evan/DeviceContext.hpp"
#include "evan/openxr/XrDeviceBackend.hpp"
#include "evan/openxr/XrSwapchainImage.hpp"
 
#include <map>
#include <memory>
#include <optional>
#include <vector>
 
namespace evan
{
    class XrSwapchainContext: public ASwapchainContext
    {
        public:
        XrSwapchainContext(const DeviceContext &deviceContext);
 
        void destroy(VkDevice device) override;
 
        void recreateSwapchain(const DeviceContext &deviceContext,
                               VkRenderPass renderpass) override;
 
        VkResult aquireImage(uint32_t index, VkDevice device,
                             VkSemaphore imageAvailableSemaphore,
                             VkFence inFlightFence,
                             uint32_t &imageIndex) override;
 
        void waitForImage(uint32_t index) override;
 
        void updateProjectionLayerViews();
 
        const std::vector<XrCompositionLayerProjectionView> &
            getProjectionLayerViews() const;
 
        ViewSet &getViewSet() override;
 
        const ViewSet &getViewSet() const override;
 
        VkSampleCountFlagBits getMsaaSamples() const override;
 
        bool usesMultiview() const override;
 
        void syncViewSet();
 
        void setView(std::size_t index,
                     const utility::graphic::ViewF &view) override;
 
        std::vector<XrView> _views;
 
        std::vector<XrViewConfigurationView> _viewsConfigurations;
 
        private:
        void selectMsaaSamples(const DeviceContext &deviceContext);
 
        struct SwapchainHandle {
            XrSwapchain swapchain = XR_NULL_HANDLE;
            XrSwapchainCreateInfo createInfo {};
        };
 
        std::optional<SwapchainHandle>
            createMultiviewSwapchain(const DeviceContext &deviceContext,
                                     VkFormat swapchainFormat);
 
        std::vector<SwapchainHandle>
            createPerViewSwapchains(const DeviceContext &deviceContext,
                                    VkFormat swapchainFormat);
 
        void buildSwapchainImages(const DeviceContext &deviceContext,
                                  const std::vector<SwapchainHandle> &handles);
 
        bool viewConfigurationsShareLayout() const;
 
        ViewSet _viewSet;
 
        VkSampleCountFlagBits _msaaSamples = VK_SAMPLE_COUNT_1_BIT;
 
        bool _multiviewEnabled = false;
 
        ColorAttachmentMode _colorAttachmentMode =
            ColorAttachmentMode::SwapchainImageAttachment;
 
        std::vector<XrCompositionLayerProjectionView> _projectionLayerViews;
 
        float _nearPlane;
 
        float _farPlane;
 
        utility::graphic::PoseF _baseCenterPose {};
 
        bool _hasBaseCenter { false };
    };
}    // namespace evan