Headset.h

Go to the documentation of this file.

#pragma once
#include <glm/ext/matrix_float4x4.hpp>
#include <openxr/openxr.h>
#include <vector>
#include <memory>
#include <vulkan/vulkan_core.h>
 
class NamedThreadPool;
 
namespace EngineCore
{
class ApplicationContext;
    class Renderer;
}
 
namespace EngineCore
{

struct RenderTarget
{
    VkImage image = nullptr;
    VkImageView imageView = nullptr;
    VkFramebuffer framebuffer = nullptr;
 
    void cleanup(const ApplicationContext* context);
 
private:
    VkImageLayout imageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
};
 
class Headset
{
  public:
    Headset(const 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
    };

    void updateViewMatrix();

    WaitFrameResult waitForXrFrame(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;

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

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

    [[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 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 ApplicationContext* context);
    };
 
    ImageBuffer colorBuffer;
    ImageBuffer depthBuffer;
 
    // Hi-Z Sampler (shared across all frames - the sampler configuration doesn't change)
    // Note: Hi-Z pyramids are now per-frame in RenderProcess to avoid cross-frame hazards
    VkSampler hiZSampler_ = VK_NULL_HANDLE;
 
    void createHiZSampler(VkDevice device);
 
    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 position offset applied to view matrices
    glm::vec3 playerPosition_{0.0f, 0.0f, 0.0f};
 
  public:
    const RenderTarget* getRenderTarget(size_t swapchainImageIndex) const;
 
    // Hi-Z sampler accessor (sampler is shared, pyramids are now per-frame in RenderProcess)
    [[nodiscard]] VkSampler getHiZSampler() const { return hiZSampler_; }
    [[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; }
};
} // namespace EngineCore