Headset.h

Go to the documentation of this file.

#pragma once
#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,        // An error occurred
            RenderFully,  // Render this frame normally
            SkipRender,   // Skip rendering the frame but end it
            SkipFully,    // Skip processing this frame entirely without ending it
            ComputeOnly   // Run compute shaders but skip XR/mesh rendering (COMPUTE_DEBUG mode)
        };

        struct WaitFrameResult
        {
            BeginFrameResult result;
            bool             shouldCallBeginFrame;        // Whether beginXrFrameAfterWait should be called
            bool needsGpuSyncForStateTransition = false;  // Deferred GPU sync + Tracy reset needed
        };

        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;
        [[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;
 
        // Named thread pool for xrWaitFrame timeout handling (visible in Tracy as "XR Wait 1")
        std::unique_ptr<NamedThreadPool> xrWaitThreadPool_;
 
    private:
        std::vector<RenderTarget> swapchainRenderTargets;
 
        std::vector<XrCompositionLayerProjectionView> eyeRenderInfos;
 
        struct Eye
        {
            glm::mat4 eyeViewMatrix{};
            glm::mat4 eyeProjectionMatrix{};
        };
 
        std::vector<Eye> eyes = {};
 
        XrTime lastUpdateTime = 0;
 
        // Player transform applied to view matrices
        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 colorFormat_ = VK_FORMAT_R8G8B8A8_UNORM;
        VkFormat sceneColorFormat_ = VK_FORMAT_R16G16B16A16_SFLOAT;
    };
}  // namespace Engine::Rendering