OpenXrHelper.h

#pragma once
 
#include <glm/gtx/quaternion.hpp>
#include <openxr/openxr.h>
#include <stdexcept>
#include <string>
 
namespace Engine
{
    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 Engine