types.hpp

#pragma once
#include <type_traits>
#include <Jolt/Jolt.h>
#include <core/math/types.hpp>
#include <glm/gtc/quaternion.hpp>
#include <glm/fwd.hpp>
 
namespace atlas {
    template<>
    struct vector3<JPH::Vec3> {
        vector3() = default;
 
        vector3(const JPH::Vec3& p_other) {
            m_value = { p_other.GetX(), p_other.GetY(), p_other.GetZ() };
        }
 
        operator glm::vec3() { return m_value; }
 
        glm::vec3 operator=(const JPH::Vec3& p_other) {
            return { p_other.GetX(), p_other.GetY(), p_other.GetZ() };
        }
 
        bool operator==(const glm::vec3& p_other) {
            return (m_value.x == p_other.x and m_value.y == p_other.y and
                    m_value.z == p_other.z);
        }
 
    private:
        glm::vec3 m_value;
    };
 
    namespace jolt {
        JPH::RVec3 to_rvec3(const glm::vec3& p_value);
 
        JPH::Vec3 to_vec3(const glm::vec3& p_value);
 
        JPH::Quat to_quat(const glm::vec4& q);
 
        JPH::Quat to_quat(glm::quat& p_value);
    };
 
    glm::vec3 to_vec3(const JPH::Vec3& p_value);
 
    glm::quat to_quat(const JPH::Quat& p_value);
 
    glm::vec4 to_vec4(const JPH::Quat& p_value);
};