XrDeviceBackend.hpp

/*
** ETIB PROJECT, 2026
** evan
** File description:
** XrBackend
*/
 
#pragma once
 
#include "evan/openxr/IXrPlatform.hpp"
#include "evan/openxr/OpenXrOptions.hpp"
#include "evan/openxr/XrManageActions.hpp"
 
#include "evan/ADeviceBackend.hpp"
 
#include <cstring>
#include <iostream>
#include <openxr/openxr.h>
#include <openxr/openxr_platform.h>
#include <vector>
 
#define LEFT_HAND_INDEX  0
#define RIGHT_HAND_INDEX 1
 
namespace evan
{
    class XrDeviceBackend: public ADeviceBackend
    {
        public:
        XrDeviceBackend(const IPlatform &platform);
 
        ~XrDeviceBackend() override;
 
        Error preprocessFrame(ASwapchainContext &swapchainContext) override;
 
        Error processFrame(VkPresentInfoKHR presentInfo,
                           ASwapchainImage &swapchainImage) override;
 
        Error postprocessFrame(ASwapchainContext &swapchainContext) override;
 
        QueueFamilyIndices findQueueFamilies() override;
 
        uint32_t countSwapchainFormats() const override;
 
        std::vector<int64_t> enumerateSwapchainFormats(
            uint32_t swapchainFormatCount) const override;
 
        std::vector<XrViewConfigurationView>
            enumerateViewConfigurations() const;
 
        std::vector<std::shared_ptr<utility::event::Event>> pollActions();
 
        XrSession getSession() const
        {
            return _session;
        }
 
        XrViewConfigurationType getViewConfigurationType() const
        {
            return _viewConfigurationType;
        }
 
        const OpenXrOptions &getOpenXrOptions() const
        {
            return _openXrOptions;
        }
 
        std::vector<XrViewConfigurationType>
            enumerateViewConfigurationTypes() const;
 
        static XrViewConfigurationType selectViewConfigurationType(
            const std::vector<XrViewConfigurationType> &configurations);
 
        XrInstance _XrInstance = XR_NULL_HANDLE;
 
        XrSystemId _systemId = XR_NULL_SYSTEM_ID;
 
        XrSession _session = XR_NULL_HANDLE;
 
        XrSpace _space = XR_NULL_HANDLE;
 
        std::unique_ptr<XrManageActions> _actionManager;
 
        bool _sessionRunning = false;
 
        XrTime _predictedDisplayTime = 0;
 
        const static size_t _handCount = 2;
 
        std::array<XrPath, _handCount> _handActionSubactionPath;
 
        protected:
        void createInstance(const IPlatform &platform,
                            const std::string &appName,
                            Version &appVersion) override;
 
        void createLogicalDevice() override;
 
        void pickPhysicalDevice() override;
 
        void createVisualizedSpace();
 
        std::vector<VkExtensionProperties> getInstanceExtensions() const;
 
        private:
        void createXrInstance(const IPlatform &platform);
 
        void getSystem();
 
        void createSession();
 
        std::vector<const char *> getRequiredInstanceExtensions() const;
 
        std::vector<const char *> getRequiredInstanceExtensionsAndroid();
 
        XrViewConfigurationType _viewConfigurationType =
            XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO;
 
        uint32_t _vulkanApiVersion = VK_API_VERSION_1_0;
 
        OpenXrOptions _openXrOptions;
    };
}    // namespace evan