Chris Robinson
e64c52ce8c
To help stablize sources near the listener, when away from origin. Also clean up some related methods and move them to more appropriate places.
117 lines
3.5 KiB
C++
117 lines
3.5 KiB
C++
#ifndef COMMON_VECMAT_H
|
|
#define COMMON_VECMAT_H
|
|
|
|
#include <array>
|
|
#include <cmath>
|
|
#include <cstddef>
|
|
#include <limits>
|
|
|
|
#include "alspan.h"
|
|
|
|
|
|
namespace alu {
|
|
|
|
template<typename T, std::enable_if_t<std::is_floating_point<T>::value, bool> = true>
|
|
class VectorR {
|
|
alignas(16) std::array<T,4> mVals;
|
|
|
|
public:
|
|
constexpr VectorR() noexcept = default;
|
|
constexpr VectorR(const VectorR&) noexcept = default;
|
|
constexpr VectorR(T a, T b, T c, T d) noexcept : mVals{{a, b, c, d}} { }
|
|
|
|
constexpr VectorR& operator=(const VectorR&) noexcept = default;
|
|
|
|
T& operator[](size_t idx) noexcept { return mVals[idx]; }
|
|
constexpr const T& operator[](size_t idx) const noexcept { return mVals[idx]; }
|
|
|
|
VectorR& operator+=(const VectorR &rhs) noexcept
|
|
{
|
|
mVals[0] += rhs.mVals[0];
|
|
mVals[1] += rhs.mVals[1];
|
|
mVals[2] += rhs.mVals[2];
|
|
mVals[3] += rhs.mVals[3];
|
|
return *this;
|
|
}
|
|
|
|
T normalize()
|
|
{
|
|
const T length{std::sqrt(mVals[0]*mVals[0] + mVals[1]*mVals[1] + mVals[2]*mVals[2])};
|
|
if(length > std::numeric_limits<T>::epsilon())
|
|
{
|
|
T inv_length{T{1}/length};
|
|
mVals[0] *= inv_length;
|
|
mVals[1] *= inv_length;
|
|
mVals[2] *= inv_length;
|
|
return length;
|
|
}
|
|
mVals[0] = mVals[1] = mVals[2] = T{0};
|
|
return T{0};
|
|
}
|
|
|
|
constexpr VectorR cross_product(const alu::VectorR<T> &rhs) const
|
|
{
|
|
return VectorR{
|
|
(*this)[1]*rhs[2] - (*this)[2]*rhs[1],
|
|
(*this)[2]*rhs[0] - (*this)[0]*rhs[2],
|
|
(*this)[0]*rhs[1] - (*this)[1]*rhs[0],
|
|
T{0}};
|
|
}
|
|
|
|
constexpr T dot_product(const alu::VectorR<T> &rhs) const
|
|
{ return (*this)[0]*rhs[0] + (*this)[1]*rhs[1] + (*this)[2]*rhs[2]; }
|
|
};
|
|
using Vector = VectorR<float>;
|
|
|
|
template<typename T, std::enable_if_t<std::is_floating_point<T>::value, bool> = true>
|
|
class MatrixR {
|
|
alignas(16) std::array<T,16> mVals;
|
|
|
|
public:
|
|
constexpr MatrixR() noexcept = default;
|
|
constexpr MatrixR(const MatrixR&) noexcept = default;
|
|
constexpr MatrixR(T aa, T ab, T ac, T ad,
|
|
T ba, T bb, T bc, T bd,
|
|
T ca, T cb, T cc, T cd,
|
|
T da, T db, T dc, T dd) noexcept
|
|
: mVals{{aa,ab,ac,ad, ba,bb,bc,bd, ca,cb,cc,cd, da,db,dc,dd}}
|
|
{ }
|
|
|
|
constexpr MatrixR& operator=(const MatrixR&) noexcept = default;
|
|
|
|
auto operator[](size_t idx) noexcept { return al::span<T,4>{&mVals[idx*4], 4}; }
|
|
constexpr auto operator[](size_t idx) const noexcept
|
|
{ return al::span<const T,4>{&mVals[idx*4], 4}; }
|
|
|
|
static constexpr MatrixR Identity() noexcept
|
|
{
|
|
return MatrixR{
|
|
T{1}, T{0}, T{0}, T{0},
|
|
T{0}, T{1}, T{0}, T{0},
|
|
T{0}, T{0}, T{1}, T{0},
|
|
T{0}, T{0}, T{0}, T{1}};
|
|
}
|
|
};
|
|
using Matrix = MatrixR<float>;
|
|
|
|
template<typename T>
|
|
inline VectorR<T> operator*(const MatrixR<T> &mtx, const VectorR<T> &vec) noexcept
|
|
{
|
|
return VectorR<T>{
|
|
vec[0]*mtx[0][0] + vec[1]*mtx[1][0] + vec[2]*mtx[2][0] + vec[3]*mtx[3][0],
|
|
vec[0]*mtx[0][1] + vec[1]*mtx[1][1] + vec[2]*mtx[2][1] + vec[3]*mtx[3][1],
|
|
vec[0]*mtx[0][2] + vec[1]*mtx[1][2] + vec[2]*mtx[2][2] + vec[3]*mtx[3][2],
|
|
vec[0]*mtx[0][3] + vec[1]*mtx[1][3] + vec[2]*mtx[2][3] + vec[3]*mtx[3][3]};
|
|
}
|
|
|
|
template<typename U, typename T>
|
|
inline VectorR<U> cast_to(const VectorR<T> &vec) noexcept
|
|
{
|
|
return VectorR<U>{static_cast<U>(vec[0]), static_cast<U>(vec[1]),
|
|
static_cast<U>(vec[2]), static_cast<U>(vec[3])};
|
|
}
|
|
|
|
} // namespace alu
|
|
|
|
#endif /* COMMON_VECMAT_H */
|