tri11paragon
/
BLT
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

hash_value on vec

v2
Brett 2024-12-10 00:33:04 -05:00
parent d1a9aab859
commit 1798980ac6
2 changed files with 335 additions and 318 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -1,6 +1,6 @@
cmake_minimum_required(VERSION 3.20)
include(cmake/color.cmake)
set(BLT_VERSION 2.1.12)
set(BLT_VERSION 2.1.13)
set(BLT_TARGET BLT)

81
include/blt/math/vectors.h
View File

@ -17,7 +17,6 @@
namespace blt
{
#define MSVC_COMPILER (!defined(__GNUC__) && !defined(__clang__))
constexpr float EPSILON = std::numeric_limits<float>::epsilon();
@ -27,12 +26,14 @@ namespace blt
return v1 >= v2 - EPSILON && v1 <= v2 + EPSILON;
}
template<typename T, blt::u32 size>
template <typename T, blt::u32 size>
struct vec
{
static_assert(std::is_arithmetic_v<T> && "blt::vec must be created using an arithmetic type!");
private:
std::array<T, size> elements;
public:
constexpr static blt::u32 data_size = size;
@ -47,7 +48,7 @@ namespace blt
* @param t default value to fill with
* @param args list of args
*/
template<typename U, std::enable_if_t<std::is_same_v<T, U> || std::is_convertible_v<U, T>, bool> = true>
template <typename U, std::enable_if_t<std::is_same_v<T, U> || std::is_convertible_v<U, T>, bool> = true>
constexpr vec(U t, std::initializer_list<U> args): elements()
{
auto b = args.begin();
@ -67,13 +68,15 @@ namespace blt
* Create a vector from an initializer list, if the list doesn't have enough elements it will be filled with the default value (0)
* @param args
*/
template<typename U, std::enable_if_t<std::is_same_v<T, U> || std::is_convertible_v<U, T>, bool> = true>
template <typename U, std::enable_if_t<std::is_same_v<T, U> || std::is_convertible_v<U, T>, bool> = true>
constexpr vec(std::initializer_list<U> args): vec(U(), args)
{}
{
}
template<typename... Args, std::enable_if_t<sizeof...(Args) == size, bool> = true>
template <typename... Args, std::enable_if_t<sizeof...(Args) == size, bool> = true>
constexpr explicit vec(Args... args): vec(std::array<T, size>{static_cast<T>(args)...})
{}
{
}
constexpr explicit vec(T t)
{
@ -88,9 +91,10 @@ namespace blt
}
constexpr explicit vec(std::array<T, size> elem): elements(elem)
{}
{
}
template<typename G, size_t base_size, std::enable_if_t<std::is_convertible_v<G, T>, bool> = true>
template <typename G, size_t base_size, std::enable_if_t<std::is_convertible_v<G, T>, bool> = true>
constexpr explicit vec(std::array<G, base_size> el): elements()
{
auto b = el.begin();
@ -242,9 +246,11 @@ namespace blt
{
// cross is only defined on vectors of size 3. 2D could be implemented, which is a TODO
static_assert(size == 3);
return {left.y() * right.z() - left.z() * right.y(),
return {
left.y() * right.z() - left.z() * right.y(),
left.z() * right.x() - left.x() * right.z(),
left.x() * right.y() - left.y() * right.x()};
left.x() * right.y() - left.y() * right.x()
};
}
constexpr static inline vec<T, size> project(
@ -295,9 +301,17 @@ namespace blt
{
return elements.cend();
}
friend std::size_t hash_value(const vec& obj)
{
std::size_t seed = 0x5410391E;
for (const auto& v : obj)
seed ^= (seed << 6) + (seed >> 2) + std::hash<T>{}(v);
return seed;
}
};
template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() + std::declval<G>())>
template <typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() + std::declval<G>())>
inline constexpr vec<R, size> operator+(const vec<T, size>& left, const vec<G, size>& right)
{
vec<R, size> initializer{};
@ -306,7 +320,7 @@ namespace blt
return initializer;
}
template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() - std::declval<G>())>
template <typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() - std::declval<G>())>
inline constexpr vec<R, size> operator-(const vec<T, size>& left, const vec<G, size>& right)
{
vec<R, size> initializer{};
@ -315,7 +329,7 @@ namespace blt
return initializer;
}
template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() + std::declval<G>())>
template <typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() + std::declval<G>())>
inline constexpr vec<R, size> operator+(const vec<T, size>& left, G right)
{
vec<R, size> initializer{};
@ -324,7 +338,7 @@ namespace blt
return initializer;
}
template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() - std::declval<G>())>
template <typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() - std::declval<G>())>
inline constexpr vec<R, size> operator-(const vec<T, size>& left, G right)
{
vec<R, size> initializer{};
@ -333,7 +347,7 @@ namespace blt
return initializer;
}
template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() + std::declval<G>())>
template <typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() + std::declval<G>())>
inline constexpr vec<R, size> operator+(G left, const vec<T, size>& right)
{
vec<R, size> initializer{};
@ -342,7 +356,7 @@ namespace blt
return initializer;
}
template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() - std::declval<G>())>
template <typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() - std::declval<G>())>
inline constexpr vec<R, size> operator-(G left, const vec<T, size>& right)
{
vec<R, size> initializer{};
@ -351,7 +365,7 @@ namespace blt
return initializer;
}
template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() * std::declval<G>())>
template <typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() * std::declval<G>())>
inline constexpr vec<R, size> operator*(const vec<T, size>& left, const vec<G, size>& right)
{
vec<R, size> initializer{};
@ -360,7 +374,7 @@ namespace blt
return initializer;
}
template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() * std::declval<G>())>
template <typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() * std::declval<G>())>
inline constexpr vec<R, size> operator*(const vec<T, size>& left, G right)
{
vec<R, size> initializer{};
@ -369,7 +383,7 @@ namespace blt
return initializer;
}
template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() * std::declval<G>())>
template <typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() * std::declval<G>())>
inline constexpr vec<R, size> operator*(G left, const vec<T, size>& right)
{
vec<R, size> initializer{};
@ -378,7 +392,7 @@ namespace blt
return initializer;
}
template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() / std::declval<G>())>
template <typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() / std::declval<G>())>
inline constexpr vec<R, size> operator/(const vec<T, size>& left, G right)
{
vec<R, size> initializer{};
@ -387,7 +401,7 @@ namespace blt
return initializer;
}
template<typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() / std::declval<G>())>
template <typename T, typename G, blt::u32 size, typename R = decltype(std::declval<T>() / std::declval<G>())>
inline constexpr vec<R, size> operator/(G left, const vec<T, size>& right)
{
vec<R, size> initializer{};
@ -396,7 +410,7 @@ namespace blt
return initializer;
}
template<typename T, typename G, blt::u32 size>
template <typename T, typename G, blt::u32 size>
inline constexpr bool operator==(const vec<T, size>& left, const vec<G, size>& right)
{
constexpr double E = std::numeric_limits<T>::epsilon();
@ -409,13 +423,13 @@ namespace blt
return true;
}
template<typename T, typename G, blt::u32 size>
template <typename T, typename G, blt::u32 size>
inline constexpr bool operator!=(const vec<T, size>& left, const vec<G, size>& right)
{
return !(left == right);
}
template<typename Ret, typename T, blt::u32 size>
template <typename Ret, typename T, blt::u32 size>
inline constexpr vec<Ret, size> vec_cast(const vec<T, size>& conv)
{
vec<Ret, size> initializer{};
@ -460,25 +474,27 @@ namespace blt
return color4{r, g, b, 1.0f};
}
template<typename ValueType, u32 size>
template <typename ValueType, u32 size>
inline constexpr blt::vec<ValueType, 2> make_vec2(const blt::vec<ValueType, size>& t, size_t fill = 0)
{
if constexpr (size >= 2)
{
return blt::vec<ValueType, 2>(t.x(), t.y());
} else
}
else
{
return blt::vec<ValueType, 2>(t.x(), fill);
}
}
template<typename ValueType, u32 size>
template <typename ValueType, u32 size>
inline constexpr blt::vec<ValueType, 3> make_vec3(const blt::vec<ValueType, size>& t, size_t fill = 0)
{
if constexpr (size >= 3)
{
return blt::vec<ValueType, 3>(t.x(), t.y(), t.z());
} else
}
else
{
blt::vec<ValueType, 3> ret;
for (size_t i = 0; i < size; i++)
@ -489,13 +505,14 @@ namespace blt
}
}
template<typename ValueType, u32 size>
template <typename ValueType, u32 size>
inline constexpr blt::vec<ValueType, 4> make_vec4(const blt::vec<ValueType, size>& t, size_t fill = 0)
{
if constexpr (size >= 4)
{
return blt::vec<ValueType, 4>(t.x(), t.y(), t.z(), t.w());
} else
}
else
{
blt::vec<ValueType, 4> ret;
for (size_t i = 0; i < size; i++)
@ -525,7 +542,7 @@ namespace blt
// Gram-Schmidt orthonormalization algorithm
static inline void gramSchmidt(std::vector<vec3>& vectors)
{
int n = (int) vectors.size();
int n = (int)vectors.size();
std::vector<vec3> basis;
// normalize first vector