Vector.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Forward.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Hash.hpp"
 
#include <glm/vec2.hpp>
#include <glm/vec3.hpp>
#include <glm/vec4.hpp>
 
#define CE_EXTERN_VECTOR(D)                                         \
    extern template struct glm::vec<D, double, glm::highp>;         \
    extern template struct glm::vec<D, float, glm::highp>;          \
    extern template struct glm::vec<D, char, glm::highp>;           \
    extern template struct glm::vec<D, unsigned char, glm::highp>;  \
    extern template struct glm::vec<D, short, glm::highp>;          \
    extern template struct glm::vec<D, unsigned short, glm::highp>; \
    extern template struct glm::vec<D, int, glm::highp>;            \
    extern template struct glm::vec<D, unsigned int, glm::highp>;   \
    extern template struct glm::vec<D, long, glm::highp>;           \
    extern template struct glm::vec<D, unsigned long, glm::highp>
CE_EXTERN_VECTOR(2);
CE_EXTERN_VECTOR(3);
CE_EXTERN_VECTOR(4);
#undef CE_EXTERN_VECTOR
 
namespace CeresEngine::inline Math {
 
    template<glm::length_t D, typename T = double> using TVector = glm::vec<D, T, glm::highp>;
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T> using TVector2 = TVector<2, T>;
 
    using Vector2 CE_SCRIPT_EXPORT(name = "Vector2", external = true, plain = true)
    = TVector2<double>;
 
    using Vector2f CE_SCRIPT_EXPORT(name = "Vector2", external = true, plain = true)
    = TVector2<float>;
 
    using Vector2i CE_SCRIPT_EXPORT(name = "Vector2", external = true, plain = true)
    = TVector2<int>;
 
    using Vector2ui = TVector2<unsigned int>;
 
    using Vector2b CE_SCRIPT_EXPORT(name = "Vector2", external = true, plain = true)
    = TVector2<bool>;
 
    using Vec2 = Vector2;
 
    using Vec2f = Vector2f;
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T> using TVector3 = TVector<3, T>;
 
    using Vector3 CE_SCRIPT_EXPORT(name = "Vector3", external = true, plain = true)
    = TVector3<double>;
 
    using Vector3f CE_SCRIPT_EXPORT(name = "Vector3", external = true, plain = true)
    = TVector3<float>;
 
    using Vector3i CE_SCRIPT_EXPORT(name = "Vector3", external = true, plain = true)
    = TVector3<int>;
 
    using Vector3ui = TVector3<unsigned int>;
 
    using Vector3b CE_SCRIPT_EXPORT(name = "Vector3", external = true, plain = true)
    = TVector3<bool>;
 
    using Vec3 = Vector3;
 
    using Vec3f = Vector3f;
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T> using TVector4 = TVector<4, T>;
 
    using Vector4 CE_SCRIPT_EXPORT(name = "Vector4", external = true, plain = true)
    = TVector4<double>;
 
    using Vector4f CE_SCRIPT_EXPORT(name = "Vector4", external = true, plain = true)
    = TVector4<float>;
 
    using Vector4i CE_SCRIPT_EXPORT(name = "Vector4", external = true, plain = true)
    = TVector4<int>;
 
    using Vector4ui = TVector4<unsigned int>;
 
    using Vector4b CE_SCRIPT_EXPORT(name = "Vector4", external = true, plain = true)
    = TVector4<bool>;
 
    using Vec4 = Vector4;
 
    using Vec4f = Vector4f;
 
    template<std::size_t N, glm::length_t D, typename T> [[nodiscard]] T& get(TVector<D, T>& vector) noexcept { return vector[N]; }
 
    template<std::size_t N, glm::length_t D, typename T> [[nodiscard]] const T& get(const TVector<D, T>& vector) noexcept { return vector[N]; }
 
} // namespace CeresEngine::inline Math
 
template<glm::length_t D, typename T> struct std::tuple_size<CeresEngine::TVector<D, T>> : std::integral_constant<std::size_t, D> {};
 
template<std::size_t N, glm::length_t D, typename T> struct std::tuple_element<N, CeresEngine::TVector<D, T>> {
    using type = decltype(std::declval<CeresEngine::TVector<D, T>>()[N]);
};
 
template<glm::length_t D, typename T> struct std::hash<CeresEngine::TVector<D, T>> {
    using Type = CeresEngine::TVector<D, T>;
    constexpr size_t operator()(const Type& obj) const {
        using namespace CeresEngine;
 
        size_t seed = 0;
        for(glm::length_t i = 0; i < D; i++) {
            combine(seed, obj[i]);
        }
        return seed;
    }
};
 
#define REFL_DECLARE_CE_VECTOR(T)                 \
     \
     \
 
REFL_DECLARE_CE_VECTOR(double);
REFL_DECLARE_CE_VECTOR(float);
REFL_DECLARE_CE_VECTOR(bool);
REFL_DECLARE_CE_VECTOR(CeresEngine::Int32);
REFL_DECLARE_CE_VECTOR(CeresEngine::UInt32);
REFL_DECLARE_CE_VECTOR(CeresEngine::Int64);
REFL_DECLARE_CE_VECTOR(CeresEngine::UInt64);