primitives.hpp

Go to the documentation of this file.

#ifndef EAGINE_MATH_PRIMITIVES_HPP
#define EAGINE_MATH_PRIMITIVES_HPP
 
#include "tvec.hpp"
#include <array>
 
namespace eagine::math {
//------------------------------------------------------------------------------
template <typename T, int N, bool V>
class basic_line {
public:
    constexpr basic_line() noexcept = default;
 
    constexpr basic_line(tvec<T, N, V> orig, tvec<T, N, V> dir) noexcept
      : _origin{orig}
      , _direction{dir} {}
 
    constexpr auto origin() const noexcept -> vector<T, N, V> {
        return _origin;
    }
 
    constexpr auto direction() const noexcept -> vector<T, N, V> {
        return _direction;
    }
 
    constexpr auto point_at(T t) const noexcept -> vector<T, N, V> {
        return _origin + _direction * t;
    }
 
private:
    vector<T, N, V> _origin{};
    vector<T, N, V> _direction{};
};
 
template <typename T, bool V>
using line = basic_line<T, 3, V>;
//------------------------------------------------------------------------------
template <typename T, int N, bool V>
class basic_triangle {
public:
    constexpr basic_triangle() noexcept = default;
 
    constexpr basic_triangle(
      tvec<T, N, V> a,
      tvec<T, N, V> b,
      tvec<T, N, V> c) noexcept
      : _vertices{{a, b, c}} {}
 
    constexpr auto vertex(span_size_t index) const noexcept -> vector<T, N, V> {
        return _vertices[index];
    }
 
    constexpr auto a() const noexcept -> vector<T, N, V> {
        return _vertices[0];
    }
 
    constexpr auto b() const noexcept -> vector<T, N, V> {
        return _vertices[1];
    }
 
    constexpr auto c() const noexcept -> vector<T, N, V> {
        return _vertices[2];
    }
 
    constexpr auto ab() const noexcept -> vector<T, N, V> {
        return b() - a();
    }
 
    constexpr auto ac() const noexcept -> vector<T, N, V> {
        return c() - a();
    }
 
    constexpr auto center() const noexcept -> vector<T, N, V> {
        return (a() + b() + c()) / T(3);
    }
 
    constexpr auto normal(bool cw) const noexcept -> vector<T, N, V> {
        return cw ? cross(ac(), ab()) : cross(ab(), ac());
    }
 
private:
    std::array<vector<T, N, V>, 3> _vertices{};
};
 
template <typename T, bool V>
using triangle = basic_triangle<T, 3, V>;
//------------------------------------------------------------------------------
template <typename T, int N, bool V>
class basic_sphere {
public:
    constexpr basic_sphere() noexcept = default;
 
    constexpr basic_sphere(tvec<T, N, V> cntr, T rad) noexcept
      : _params{vector<T, N + 1, V>::from(cntr, rad)} {}
 
    constexpr auto center() const noexcept -> vector<T, N, V> {
        return vector<T, N, V>::from(_params);
    }
 
    constexpr auto radius() const noexcept -> T {
        return _params[N];
    }
 
private:
    vector<T, N + 1, V> _params{};
};
 
template <typename T, bool V>
using sphere = basic_sphere<T, 3, V>;
//------------------------------------------------------------------------------
} // namespace eagine::math
 
#endif // EAGINE_MATH_PRIMITIVES_HPP