OpenXrHelper.h

Go to the documentation of this file.

#pragma once
 
#include <array>
#include <glm/gtx/quaternion.hpp>
#include <openxr/openxr.h>
#include <stdexcept>
#include <string>
 
namespace EngineCore
{
class OpenXrHelper
{
  public:
    typedef struct posef
    {
        glm::quat orientation{};
        glm::vec3 position{};
    } posef;

    template <typename T> 
    static void LoadXrFunction(XrInstance xrInstance, const std::string& functionName, T& functionPointer)
    {
        XrResult result = xrGetInstanceProcAddr(xrInstance, functionName.c_str(), reinterpret_cast<PFN_xrVoidFunction*>(&functionPointer));
        if (result != XR_SUCCESS)
        {
            functionPointer = nullptr;
            throw std::runtime_error("Failed to load " + functionName + " with error code: " + std::to_string(result));
        }
 
        if (!functionPointer)
        {
            functionPointer = nullptr;
            throw std::runtime_error("Failed to load " + functionName + ". The function was a nullptr");
        }
    }

    static XrPosef makeIdentityPose();

    static glm::mat4 poseToMatrix(const XrPosef& pose);

    static glm::mat4 poseToMatrix(const OpenXrHelper::posef& pose);
 
    // janhsimons math functions (found undocumented)
    // Adjustments to naming have been made. Like changing all variables from being named src to
    // something more descriptive.

    static glm::quat xrQuaternionfToGlmQuat(const XrQuaternionf& xrQuaternion);

    static XrQuaternionf glmQuatToXrQuaternionf(const glm::quat& glmQuaternion);

    static glm::vec3 xrVector3fToGlmVec3(const XrVector3f& xrVector3);

    static XrVector3f glmVec3ToXrVector3f(const glm::vec3& glmVector3);

    static float dot(const glm::quat& a, const glm::quat& b);

    static glm::quat lerpMix(const glm::quat& from, const glm::quat& to, float progress);

    static glm::vec3 lerpMix(const glm::vec3& from, const glm::vec3& to, float progress);

    static float lerpMix(float from, float to, float progress);

    static float dot(const glm::vec3& a, const glm::vec3& b);
    static glm::vec3 crossProductVector3(const glm::vec3& vector_a, const glm::vec3& vector_b);
    static float clampf(float num, float left, float right);
    static float lengthSquared(const glm::vec3& vec);
    static float length(const glm::vec3& vec);
    static glm::vec3 normalize(const glm::vec3& vec);
    static float distanceSquared(const glm::vec3& vec1, const glm::vec3& vec2);
    static float distance(const glm::vec3& vec1, const glm::vec3& vec2);
    static glm::quat slerp(const glm::quat& start, const glm::quat& end, float percent);
    static glm::vec3 slerp(const glm::vec3& start, const glm::vec3& end, float percent);
    static float vectorAngleAroundNormal(const glm::vec3& vec1, const glm::vec3& vec2, const glm::vec3& norm);
    static glm::mat4 rotationAroundPoint(glm::vec3 point, glm::mat4 rotationMatrix);
    static void quaternionToAngleAxis(const glm::quat& quat, float& angle, glm::vec3& axis);
    static glm::quat quaternionFromAngleAxis(const float& angle, const glm::vec3& axis);
    static posef xrPosefToGlmPosef(const XrPosef& xrPosef);
    static glm::mat4 createProjectionMatrix(XrFovf fov, float nearClip, float farClip);
 
    static std::string sessionStateToString(XrSessionState state);
    static const char* GetXrStructureTypeName(XrStructureType type);
};
} // namespace EngineCore