matrix_reflection.hpp

Go to the documentation of this file.

#ifndef EAGINE_MATH_MATRIX_REFLECTION_HPP
#define EAGINE_MATH_MATRIX_REFLECTION_HPP
 
#include "matrix_ctr.hpp"
#include <cmath>
 
namespace eagine::math {
 
// reflection_I
template <typename X, int I>
class reflection_I;
 
// is_matrix_constructor<reflection_I>
template <typename T, int N, bool RM, bool V, int I>
struct is_matrix_constructor<reflection_I<matrix<T, N, N, RM, V>, I>>
  : std::true_type {};
 
template <typename T, bool RM, bool V, int I>
class reflection_I<matrix<T, 4, 4, RM, V>, I> {
public:
    constexpr reflection_I(bool r = true) noexcept
      : _v(r ? T(-1) : T(1)) {}
 
    constexpr auto v(int i) const noexcept -> T {
        return (I == i) ? _v : T(1);
    }
 
    constexpr auto operator()() const noexcept {
        return matrix<T, 4, 4, RM, V>{
          {{v(0), T(0), T(0), T(0)},
           {T(0), v(1), T(0), T(0)},
           {T(0), T(0), v(2), T(0)},
           {T(0), T(0), T(0), T(1)}}};
    }
 
private:
    T _v;
};
 
// multiply
template <typename T, int N, bool RM1, bool RM2, bool V, int I>
static constexpr auto multiply(
  const reflection_I<matrix<T, N, N, RM1, V>, I>& a,
  const reflection_I<matrix<T, N, N, RM2, V>, I>& b) noexcept
  -> reflection_I<matrix<T, N, N, RM1, V>, I> {
    return {(a._v < b._v) || (a._v > b._v)};
}
 
// reorder_mat_ctr(reflection_I)
template <typename T, int N, bool RM, bool V, int I>
static constexpr auto
reorder_mat_ctr(const reflection_I<matrix<T, N, N, RM, V>, I>& c) noexcept
  -> reflection_I<matrix<T, N, N, !RM, V>, I> {
    return {c._v < T(0)};
}
 
template <typename M>
using reflection_x = reflection_I<M, 0>;
 
template <typename M>
using reflection_y = reflection_I<M, 1>;
 
template <typename M>
using reflection_z = reflection_I<M, 2>;
 
template <typename T, bool V>
using matrix_reflection_x =
  convertible_matrix_constructor<reflection_x<matrix<T, 4, 4, true, V>>>;
 
template <typename T, bool V>
using matrix_reflection_y =
  convertible_matrix_constructor<reflection_y<matrix<T, 4, 4, true, V>>>;
 
template <typename T, bool V>
using matrix_reflection_z =
  convertible_matrix_constructor<reflection_z<matrix<T, 4, 4, true, V>>>;
 
} // namespace eagine::math
 
#endif // EAGINE_MATH_MATRIX_REFLECTION_HPP