XRManager.h

Go to the documentation of this file.

#pragma once
#include "XRInterface/Headers/XRInstance.h"
#include "XRInterface/Headers/XRErrorHandling.h"
#include "XRInterface/Headers/XRVulkanPipeline.h"
#include "XRInterface/Headers/XRCameraView.h"
#include "NDEVR/Headers/QTModelManager.h"
#include "NDEVR/Headers/WindowManager3D.h"
#include "Design/Headers/CameraManager.h"
#include <QObject>
namespace NDEVR
{
    class DistanceMeasureModel;
    class PointMeasureModel;
    class XRHand;
    class XRInputManager;
    /**--------------------------------------------------------------------------------------------------
    \brief Manages the OpenXR engine at a high level.
    **/
    class XRManager
    {
    public:
        XRManager(QTModelManager* manager);
        void getAvialableBlendModes(XrViewConfigurationType type);
        void InitializeSession();
        void setupSession();
        void createCameras();
        void renderFrame();
        bool renderLayer(XrTime predictedDisplayTime, Buffer<XrCompositionLayerProjectionView>& projectionLayerViews, XrCompositionLayerProjection& layer);
        bool isSessionRunning() const { return m_session_running; }
        bool isSessionFocused() const { return m_session_state == XR_SESSION_STATE_FOCUSED; }
        XrEnvironmentBlendMode environmentBlendMode() { return m_current_blend_mode; }
        void pollActions();
        // Return event if one is available, otherwise return null.
        const XrEventDataBaseHeader* tryReadNextEvent();
        void pollEvents(bool* exitRenderLoop, bool* requestRestart);
        void start();
        void renderLoop();
        void HandleSessionStateChangedEvent(const XrEventDataSessionStateChanged& stateChangedEvent, bool* exitRenderLoop, bool* requestRestart);
        XrInstance xrInstance() const { return m_device->xrInstance(); }
        XrSystemId xrSystemID() const { return m_device->xrSystemID(); }
        XrSession xrSession() const { return m_xr_session; }
        const XrBaseInStructure* graphicsBinding() const { return reinterpret_cast<const XrBaseInStructure*>(&m_device->graphicsBinding()); }
        XrViewConfigurationType viewConfigType() const { return XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO; }
        void setSessionEndFunction(std::function<void()> function) { m_session_end_function = function; }
        void updateMovement();
        
        Matrix<fltp08> globalTransform() const;
    private:
 
        XRInputManager* m_input_manager;
        
        Vertex<3, fltp08> m_initial_offset = Constant<Vertex<3, fltp08>>::Invalid;
        GraphicsUpdater* m_updater = nullptr;
        DynamicPointer<Camera> m_reference_camera;
        Buffer<XRCameraView*> m_cameras;
        QTModelManager* m_manager;
        Thread* m_thread;
        std::function<void()> m_session_end_function;
 
        DynamicPointer<VulkanXRDevice> m_device;
        XrSpace m_appSpace{ XR_NULL_HANDLE };
 
        Buffer<XrEnvironmentBlendMode> m_available_blend_modes;
        XrEnvironmentBlendMode m_current_blend_mode;
 
        XrSession m_xr_session{ XR_NULL_HANDLE };
        // Application's current lifecycle state according to the runtime
        XrSessionState m_session_state{ XR_SESSION_STATE_UNKNOWN };
        
        //Buffer<XrSpace> m_visualizedSpaces;
        XrEventDataBuffer m_event_data_buffer;
        
        
        Buffer<XrViewConfigurationView> m_config_views;
        Buffer<XRVulkanPipeline> m_pipelines;
        Buffer<XrView> m_views;
        fltp08 m_camera_speed;
        Log* m_log = nullptr;
        Time m_last_update_time;
        bool m_session_running{ false };
    };
}