vector.hpp

Go to the documentation of this file.

#pragma once
 
#include <array>
#include <boost/describe.hpp>
#include <cmath>
 
namespace wren::math {
 
template <typename T, std::size_t N>
struct Vec {
  using vec_t = Vec<T, N>;
 
  static auto unit_x() { return vec_t{1.0f}; }
  static auto unit_y() { return vec_t{0.0f, 1.0f}; }
  static auto unit_z() { return vec_t{0.0f, 0.0f, 1.0f}; }
 
  constexpr Vec() : data() {}
 
  constexpr Vec(std::array<T, N> data) : data(data) {}
  constexpr Vec(float scalar) {
    for (size_t i = 0; i < N; ++i) {
      data.at(i) = scalar;
    }
  }
 
  template <typename... Args>
  constexpr Vec(Args... args)
    requires(sizeof...(Args) > 1)
      : data({std::forward<Args>(args)...}) {}
 
  template <std::size_t NewN>
  constexpr Vec(const Vec<T, NewN>& other) {
    static_assert(
        NewN > N,
        "Can only construct a vector from another with fewer dimensions");
    for (size_t i = 0; i < N; ++i) {
      data.at(i) = other.data.at(i);
    }
  }
 
  // Swizzles
  [[nodiscard]] auto xyz() const {
    static_assert(N > 3, "xyz swizzle requires 4 or more components ");
    return Vec<T, 3>{data.at(0), data.at(1), data.at(2)};
  }
 
  auto at(std::size_t i) -> T& { return data.at(i); }
  [[nodiscard]] auto at(std::size_t i) const { return data.at(i); }
 
  constexpr auto operator*=(float scalar) const {
    for (auto& d : data) {
      d *= scalar;
    }
  }
 
  constexpr auto operator*(float scalar) const {
    vec_t v{};
    for (std::size_t i = 0; i < N; i++) v.data.at(i) = data.at(i) * scalar;
    return v;
  }
 
  constexpr auto operator*=(const vec_t& other) {
    for (std::size_t i = 0; i < N; i++) {
      data.at(i) = data.at(i) * other.data.at(i);
    }
  }
 
  constexpr auto operator*(const vec_t& other) const {
    vec_t v{};
    for (std::size_t i = 0; i < N; i++) {
      v.data.at(i) = data.at(i) * other.data.at(i);
    }
    return v;
  }
 
  [[nodiscard]] constexpr auto dot(const vec_t& other) const {
    T dot = 0;
    for (std::size_t i = 0; i < N; i++)
      dot += this->data.at(i) * other.data.at(i);
    return dot;
  }
 
  [[nodiscard]] auto cross(const vec_t other) const {
    static_assert(N == 3, "Cross product is only defined for 3D vectors");
    vec_t result{};
    result.data.at(0) = this->data.at(1) * other.data.at(2) -
                        this->data.at(2) * other.data.at(1);
    result.data.at(1) = this->data.at(2) * other.data.at(0) -
                        this->data.at(0) * other.data.at(2);
    result.data.at(2) = this->data.at(0) * other.data.at(1) -
                        this->data.at(1) * other.data.at(0);
    return result;
  }
 
  auto operator%(const vec_t& other) const {
    static_assert(N == 3, "Cross product is only defined for 3D vectors");
    return cross(other);
  }
 
  constexpr auto operator+=(const vec_t& other) {
    for (std::size_t i = 0; i < N; i++)
      data.at(i) = data.at(i) + other.data.at(i);
  }
 
  constexpr auto operator+(const vec_t& other) const {
    vec_t v{};
    for (std::size_t i = 0; i < N; i++)
      v.data.at(i) = data.at(i) + other.data.at(i);
    return v;
  }
 
  constexpr auto operator-=(const vec_t& other) {
    for (std::size_t i = 0; i < N; i++) {
      data.at(i) = data.at(i) - other.data.at(i);
    }
  }
 
  constexpr auto operator-(const vec_t& other) const {
    vec_t v{};
    for (std::size_t i = 0; i < N; i++)
      v.data.at(i) = data.at(i) - other.data.at(i);
    return v;
  }
 
  constexpr auto operator-() const {
    vec_t v{};
    for (std::size_t i = 0; i < N; i++) v.data.at(i) = -data.at(i);
    return v;
  }
 
  auto operator/(float scalar) const {
    vec_t v{};
    for (std::size_t i = 0; i < N; i++) v.data.at(i) = data.at(i) / scalar;
    return v;
  }
 
  constexpr auto operator==(const vec_t& other) const {
    return data == other.data;
  }
 
  constexpr auto operator!=(const vec_t& other) const {
    return !(*this == other);
  }
 
  [[nodiscard]] constexpr auto length() const {
    T sum = 0;
    for (const auto& d : data) sum += d * d;
    return std::sqrt(sum);
  }
 
  [[nodiscard]] auto normalized() const { return *this / length(); }
 
  std::array<T, N> data{};
};
 
template <typename T, std::size_t N>
auto operator*(float scalar, Vec<T, N> vec) -> Vec<T, N> {
  return vec * scalar;
}
 
struct Vec2f : Vec<float, 2> {
  Vec2f() : Vec<float, 2>() {}
  Vec2f(float x, float y) : Vec<float, 2>(x, y) {}
  Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}
 
  [[nodiscard]] auto x() const { return data.at(0); }
  auto x(float x) { data.at(0) = x; }
  [[nodiscard]] auto y() const { return data.at(1); }
  auto y(float y) { data.at(1) = y; }
};
 
BOOST_DESCRIBE_STRUCT(Vec2f, (), (data));
 
struct Vec3f : Vec<float, 3> {
  Vec3f() : Vec<float, 3>() {}
  Vec3f(const auto& other) : Vec<float, 3>(other) {}
  // Vec3f(float scalar) : Vec<float, 3>({scalar, scalar, scalar}) {}
  Vec3f(float x, float y, float z) : Vec<float, 3>(x, y, z) {}
  Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}
  Vec3f(const Vec2f& vec, float z) : Vec<float, 3>(vec.x(), vec.y(), z) {}
 
  [[nodiscard]] auto x() const { return data.at(0); }
  auto x(float x) { data.at(0) = x; }
  [[nodiscard]] auto y() const { return data.at(1); }
  auto y(float y) { data.at(1) = y; }
  [[nodiscard]] auto z() const { return data.at(2); }
  [[nodiscard]] auto z() -> float& { return data.at(2); }
  auto z(float z) { data.at(2) = z; }
};
BOOST_DESCRIBE_STRUCT(Vec3f, (), (data));
 
struct Vec4f : Vec<float, 4> {
  Vec4f() : Vec<float, 4>() {}
  Vec4f(const auto& other) : Vec<float, 4>(other) {}
  Vec4f(float x, float y, float z, float w) : Vec<float, 4>(x, y, z, w) {}
  Vec4f(const Vec3f& vec, float w)
      : Vec<float, 4>(vec.x(), vec.y(), vec.z(), w) {}
  Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}
  // Vec4f(std::array<float, 4> data) : Vec<float, 4>(data) {}
 
  [[nodiscard]] auto x() const { return data.at(0); }
  [[nodiscard]] auto y() const { return data.at(1); }
  [[nodiscard]] auto z() const { return data.at(2); }
  [[nodiscard]] auto w() const { return data.at(3); }
};
BOOST_DESCRIBE_STRUCT(Vec4f, (), (data));
 
}  // namespace wren::math