Headset.h

#pragma once
#include <functional>
#include <glm/ext/matrix_float4x4.hpp>
#include <glm/gtc/quaternion.hpp>
#include <memory>
#include <openxr/openxr.h>
#include <vector>
#include <vulkan/vulkan_core.h>

 
class NamedThreadPool;
 
namespace Engine::Core
{
    class ApplicationContext;
}  // namespace Engine::Core
 
namespace Engine::Rendering
{
    class Renderer;

    struct RenderTarget
    {
        VkImage       image       = nullptr;  
        VkImageView   imageView   = nullptr;  
        VkFramebuffer framebuffer = nullptr;  

        void cleanup( const Core::ApplicationContext * context );
 
    private:
        VkImageLayout imageLayout = VK_IMAGE_LAYOUT_UNDEFINED;  
    };

    class Headset
    {
    public:
        Headset( const Core::ApplicationContext * context = nullptr );

        ~Headset();

        void cleanup();

        enum class BeginFrameResult
        {
            Error,        
            RenderFully,  
            SkipRender,   
            SkipFully,    
            ComputeOnly   
        };

        struct WaitFrameResult
        {
            BeginFrameResult result;                                  
            bool             shouldCallBeginFrame;                    
            bool             needsGpuSyncForStateTransition = false;  
        };

        void updateViewMatrix();

        WaitFrameResult waitForXrFrame( Rendering::Renderer * renderer );

        BeginFrameResult beginXrFrameAfterWait( uint32_t & swapchainImageIndex );

        BeginFrameResult beginXrFrame( uint32_t & swapchainImageIndex, Renderer * renderer );

        void endXrFrame();

        void endXrFrameNoRender();

        void beginXrSession() const;

        void setSessionStateCallback( std::function<void( XrSessionState )> callback );

        void setInteractionProfileChangedCallback( std::function<void()> callback );

        [[nodiscard]] VkImage getSwapchainImage( size_t swapchainImageIndex ) const;

        std::vector<RenderTarget> getSwapchainRenderTargets();

        void endXrSession() const;

        void requestExitSession();

        [[nodiscard]] uint32_t getEyeCount() const;

        [[nodiscard]] VkExtent2D getEyeResolution( size_t eyeIndex ) const;

        [[nodiscard]] VkRenderPass getRenderPass() const;

        [[nodiscard]] glm::mat4 getEyeViewMatrix( size_t eyeIndex ) const;

        [[nodiscard]] glm::mat4 getRawEyeViewMatrix( size_t eyeIndex ) const;

        void setPlayerPosition( const glm::vec3 & position )
        {
            playerPosition_ = position;
        }

        [[nodiscard]] glm::vec3 getPlayerPosition() const
        {
            return playerPosition_;
        }

        void setPlayerRotation( const glm::quat & rotation );

        [[nodiscard]] glm::quat getPlayerRotation() const
        {
            return playerRotation_;
        }

        [[nodiscard]] glm::vec3 transformPlaySpacePosition( const glm::vec3 & position ) const;

        [[nodiscard]] glm::quat transformPlaySpaceOrientation( const glm::quat & orientation ) const;

        [[nodiscard]] glm::vec3 getHeadsetLocalPosition() const;

        [[nodiscard]] glm::quat getHeadsetLocalOrientation() const;

        [[nodiscard]] glm::vec3 getHeadsetWorldPosition() const;

        [[nodiscard]] glm::quat getHeadsetWorldOrientation() const;

        [[nodiscard]] glm::mat4 getEyeProjectionMatrix( size_t eyeIndex ) const;

        [[nodiscard]] glm::mat4 getViewProjectionMatrix( size_t eyeIndex ) const;

        [[nodiscard]] XrSpace getReferenceSpace() const;

        [[nodiscard]] XrSession getSession() const;

        [[nodiscard]] bool getIsExitRequested() const;

        [[nodiscard]] XrFrameState getXrFrameState() const;
 
    private:
        XrViewState  xrViewState  = {};  
        XrFrameState xrFrameState = {};  
 
        XrSessionState xrSessionState = XR_SESSION_STATE_UNKNOWN;  
 
        bool isExistRequested = false;  
 
        const Core::ApplicationContext * context = nullptr;  
 
        VkRenderPass vkRenderPass = VK_NULL_HANDLE;  
 
        XrSession xrSession = XR_NULL_HANDLE;  
 
        XrSpace              xrReferenceSpace     = XR_NULL_HANDLE;                 
        XrReferenceSpaceType xrReferenceSpaceType = XR_REFERENCE_SPACE_TYPE_LOCAL;  
 
        uint32_t eyeCount = 0u;  
 
        std::vector<XrViewConfigurationView> eyeImageInfos;  
 
        std::vector<XrView> eyePoses;  

        struct ImageBuffer
        {
            VkImage        image        = nullptr;  
            VkDeviceMemory deviceMemory = nullptr;  
            VkImageView    imageView    = nullptr;  

            void cleanup( const Core::ApplicationContext * context );
        };
 
        ImageBuffer colorBuffer;    
        ImageBuffer depthBuffer;    
        ImageBuffer resolveBuffer;  
 
        XrSwapchain xrSwapchain = nullptr;  
 
        std::unique_ptr<NamedThreadPool> xrWaitThreadPool_;  
 
        std::function<void( XrSessionState )> sessionStateCallback_;                
        std::function<void()> interactionProfileChangedCallback_;                   
 
    private:
        std::vector<RenderTarget> swapchainRenderTargets;  
 
        std::vector<XrCompositionLayerProjectionView> eyeRenderInfos;  

        struct Eye
        {
            glm::mat4 eyeViewMatrix{};        
            glm::mat4 eyeProjectionMatrix{};  
        };
 
        std::vector<Eye> eyes = {};  
 
        XrTime lastUpdateTime = 0;  
 
        glm::vec3 playerPosition_{ 0.0f, 0.0f, 0.0f };        
        glm::quat playerRotation_{ 1.0f, 0.0f, 0.0f, 0.0f };  
 
    public:
        const RenderTarget * getRenderTarget( size_t swapchainImageIndex ) const;

        [[nodiscard]] VkImage getDepthBufferImage() const
        {
            return depthBuffer.image;
        }

        [[nodiscard]] VkImageView getDepthBufferView() const
        {
            return depthBuffer.imageView;
        }

        [[nodiscard]] VkImage getColorBufferImage() const
        {
            return colorBuffer.image;
        }

        [[nodiscard]] VkImageView getColorBufferView() const
        {
            return colorBuffer.imageView;
        }

        [[nodiscard]] VkImage getResolveBufferImage() const
        {
            return resolveBuffer.image;
        }

        [[nodiscard]] VkImageView getResolveBufferView() const
        {
            return resolveBuffer.imageView;
        }

        [[nodiscard]] VkFormat getColorFormat() const
        {
            return colorFormat_;
        }

        [[nodiscard]] VkFormat getSceneColorFormat() const
        {
            return sceneColorFormat_;
        }
 
    private:
        VkFormat swapchainFormat_           = VK_FORMAT_R8G8B8A8_UNORM;       
        VkFormat colorFormat_               = VK_FORMAT_R8G8B8A8_UNORM;       
        VkFormat sceneColorFormat_          = VK_FORMAT_R16G16B16A16_SFLOAT;  
        bool     useMutableSwapchainFormat_ = false;                          
    };
}  // namespace Engine::Rendering