matrix_scale.hpp

Go to the documentation of this file.

#ifndef EAGINE_MATH_MATRIX_SCALE_HPP
#define EAGINE_MATH_MATRIX_SCALE_HPP
 
#include "matrix_ctr.hpp"
 
namespace eagine::math {
 
// scale
template <typename X>
class scale;
 
// is_matrix_constructor<scale>
template <typename T, int N, bool RM, bool V>
struct is_matrix_constructor<scale<matrix<T, N, N, RM, V>>> : std::true_type {};
 
template <typename T, bool RM, bool V>
class scale<matrix<T, 4, 4, RM, V>> {
public:
    constexpr scale(vect::data_t<T, 3, V> v) noexcept
      : _v(v) {}
 
    constexpr scale(T vx, T vy, T vz) noexcept
      : _v{vx, vy, vz} {}
 
    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)}}};
    }
 
    friend constexpr auto
    reorder_mat_ctr(const scale<matrix<T, 4, 4, RM, V>>& c) noexcept
      -> scale<matrix<T, 4, 4, !RM, V>> {
        return {c._v};
    }
 
private:
    vect::data_t<T, 3, V> _v;
};
 
// multiply
template <typename T, int N, bool RM1, bool RM2, bool V>
static constexpr auto multiply(
  const scale<matrix<T, N, N, RM1, V>>& a,
  const scale<matrix<T, N, N, RM2, V>>& b) noexcept
  -> scale<matrix<T, N, N, RM1, V>> {
    return {a._v * b._v};
}
 
// uniform_scale
template <typename X>
class uniform_scale;
 
// is_matrix_constructor<uniform_scale>
template <typename T, int N, bool RM, bool V>
struct is_matrix_constructor<uniform_scale<matrix<T, N, N, RM, V>>>
  : std::true_type {};
 
template <typename T, bool RM, bool V>
class uniform_scale<matrix<T, 4, 4, RM, V>> {
public:
    constexpr uniform_scale(T v) noexcept
      : _v(v) {}
 
    constexpr auto operator()() const noexcept {
        return matrix<T, 4, 4, RM, V>{
          {{_v, T(0), T(0), T(0)},
           {T(0), _v, T(0), T(0)},
           {T(0), T(0), _v, T(0)},
           {T(0), T(0), T(0), T(1)}}};
    }
 
    friend constexpr auto
    reorder_mat_ctr(const uniform_scale<matrix<T, 4, 4, RM, V>>& c) noexcept
      -> uniform_scale<matrix<T, 4, 4, !RM, V>> {
        return {c._v};
    }
 
private:
    T _v;
};
 
// multiply
template <typename T, int N, bool RM1, bool RM2, bool V>
static constexpr auto multiply(
  const uniform_scale<matrix<T, N, N, RM1, V>>& a,
  const uniform_scale<matrix<T, N, N, RM2, V>>& b) noexcept
  -> uniform_scale<matrix<T, N, N, RM1, V>> {
    return {a._v * b._v};
}
 
template <typename T, bool V>
using matrix_scale =
  convertible_matrix_constructor<scale<matrix<T, 4, 4, true, V>>>;
 
template <typename T, bool V>
using matrix_uniform_scale =
  convertible_matrix_constructor<uniform_scale<matrix<T, 4, 4, true, V>>>;
 
} // namespace eagine::math
 
#endif // EAGINE_MATH_MATRIX_SCALE_HPP