Vector.h

/*
 * Gamedev Framework (gf)
 * Copyright (C) 2016-2019 Julien Bernard
 *
 * This software is provided 'as-is', without any express or implied
 * warranty.  In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */
#ifndef GF_VECTOR_H
#define GF_VECTOR_H

#include <cstddef>
#include <cstdint>

#include <algorithm>
#include <initializer_list>
#include <type_traits>

#include "Portability.h"
#include "Types.h"

namespace gf {
#ifndef DOXYGEN_SHOULD_SKIP_THIS
inline namespace v1 {
#endif

  template<typename T, std::size_t N>
  struct Vector {
    #ifndef DOXYGEN_SHOULD_SKIP_THIS
    static_assert(N > 0, "N must be strictly positive");
    #endif

    Vector() = default;

    constexpr Vector(ZeroType) noexcept
    {
      zero();
    }

    explicit Vector(T val) noexcept
    {
      std::fill_n(data, N, val);
    }

    explicit Vector(const T *array)
    {
      std::copy_n(array, N, data);
    }

    Vector(std::initializer_list<T> list) noexcept
    {
      std::copy_n(list.begin(), std::min(list.size(), N), data);
    }

    Vector(const Vector& other) = default;


    template<typename U>
    Vector(const Vector<U, N>& other) noexcept
    {
      static_assert(std::is_convertible<U,T>::value, "Non-convertible types");
      std::transform(data, data + N, other.data, [](U val) { return static_cast<T>(val); });
    }

    Vector& operator=(const Vector& other) = default;

    constexpr T operator[](std::size_t i) const {
      return data[i];
    }

    constexpr T& operator[](std::size_t i) {
      return data[i];
    }


    T *begin() {
      return &data[0];
    }

    T *end() {
      return &data[N];
    }

    const T *begin() const {
      return &data[0];
    }

    const T *end() const {
      return &data[N];
    }

    const T *cbegin() const {
      return &data[0];
    }

    const T *cend() const {
      return &data[N];
    }

    constexpr void zero() noexcept {
      for (std::size_t i = 0; i < N; ++i) {
        data[i] = T{};
      }
    }

    T data[N];
  };

  template <typename T>
  struct Vector<T, 2> {
    Vector() = default;

    constexpr Vector(ZeroType) noexcept
    : x(T(0))
    , y(T(0))
    {
    }

    explicit constexpr Vector(T val) noexcept
    : x(val)
    , y(val)
    {
    }

    explicit constexpr Vector(const T *array)
    : x(array[0])
    , y(array[1])
    {
    }

    constexpr Vector(T first, T second) noexcept
    : x(first)
    , y(second)
    {
    }

    Vector(const Vector& other) = default;

    template<typename U>
    Vector(const Vector<U, 2>& other) noexcept
    : x(static_cast<T>(other.x))
    , y(static_cast<T>(other.y))
    {
      static_assert(std::is_convertible<U,T>::value, "Non-convertible types");
    }

    Vector& operator=(const Vector& other) = default;

    constexpr T operator[](std::size_t i) const {
      const T *data[] = { &x, &y };
      return *data[i];
    }

    constexpr T& operator[](std::size_t i) {
      T *data[] = { &x, &y };
      return *data[i];
    }


    T *begin() {
      return &x;
    }

    T *end() {
      return &x + 2;
    }

    const T *begin() const {
      return &x;
    }

    const T *end() const {
      return &x + 2;
    }
    const T *cbegin() const {
      return &x;
    }

    const T *cend() const {
      return &x + 2;
    }

    constexpr void zero() noexcept {
      x = y = T{};
    }

    union {
      T x; 
      T u; 
      T s; 
      T width; 
      T col; 
    };

    union {
      T y; 
      T v; 
      T t; 
      T height; 
      T row; 
    };
  };

  template <typename T>
  struct Vector<T, 3> {
    Vector() = default;

    constexpr Vector(ZeroType) noexcept
    {
      zero();
    }

    explicit constexpr Vector(T val) noexcept
    : x(val)
    , y(val)
    , z(val)
    {
    }

    explicit constexpr Vector(const T *array)
    : x(array[0])
    , y(array[1])
    , z(array[2])
    {
    }

    constexpr Vector(T first, T second, T third) noexcept
    : x(first)
    , y(second)
    , z(third)
    {
    }

    constexpr Vector(Vector<T, 2> xy, T third)
    : x(xy.x)
    , y(xy.y)
    , z(third)
    {
    }

    Vector(const Vector& other) = default;

    template<typename U>
    Vector(const Vector<U, 3>& other) noexcept
    : x(static_cast<T>(other.x))
    , y(static_cast<T>(other.y))
    , z(static_cast<T>(other.z))
    {
      static_assert(std::is_convertible<U,T>::value, "Non-convertible types");
    }

    Vector& operator=(const Vector& other) = default;

    constexpr T operator[](std::size_t i) const {
      const T *data[] = { &x, &y, &z };
      return *data[i];
    }

    constexpr T& operator[](std::size_t i) {
      T *data[] = { &x, &y, &z };
      return *data[i];
    }


    T *begin() {
      return &x;
    }

    T *end() {
      return &x + 3;
    }

    const T *begin() const {
      return &x;
    }

    const T *end() const {
      return &x + 3;
    }

    const T *cbegin() const {
      return &x;
    }

    const T *cend() const {
      return &x + 3;
    }

    constexpr void zero() noexcept {
      x = y = z = T{};
    }

    constexpr Vector<T, 2> xy() const {
      return { x, y };
    }


    union {
      T x; 
      T r; 
    };

    union {
      T y; 
      T g; 
    };

    union {
      T z; 
      T b; 
    };
  };

  template <typename T>
  struct Vector<T, 4> {
    Vector() = default;

    constexpr Vector(ZeroType) noexcept
    {
      zero();
    }

    explicit constexpr Vector(T val) noexcept
    : x(val)
    , y(val)
    , z(val)
    , w(val)
    {
    }

    explicit constexpr Vector(const T *array)
    : x(array[0])
    , y(array[1])
    , z(array[2])
    , w(array[3])
    {
    }

    constexpr Vector(T first, T second, T third, T fourth) noexcept
    : x(first)
    , y(second)
    , z(third)
    , w(fourth)
    {
    }

    Vector(const Vector& other) = default;

    template<typename U>
    Vector(const Vector<U, 4>& other) noexcept
    : x(static_cast<T>(other.x))
    , y(static_cast<T>(other.y))
    , z(static_cast<T>(other.z))
    , w(static_cast<T>(other.w))
    {
      static_assert(std::is_convertible<U,T>::value, "Non-convertible types");
    }

    Vector& operator=(const Vector& other) = default;

    constexpr T operator[](std::size_t i) const {
      const T *data[] = { &x, &y, &z, &w };
      return *data[i];
    }

    constexpr T& operator[](std::size_t i) {
      T *data[] = { &x, &y, &z, &w };
      return *data[i];
    }


    T *begin() {
      return &x;
    }

    T *end() {
      return &x + 4;
    }

    const T *begin() const {
      return &x;
    }

    const T *end() const {
      return &x + 4;
    }

    const T *cbegin() const {
      return &x;
    }

    const T *cend() const {
      return &x + 4;
    }

    constexpr void zero() noexcept {
      x = y = z = w = T{};
    }

    constexpr Vector<T, 2> xy() const {
      return { x, y };
    }

    constexpr Vector<T, 3> xyz() const {
      return { x, y, z };
    }

    constexpr Vector<T, 3> rgb() const {
      return { r, g, b };
    }


    union {
      T x; 
      T r; 
    };

    union {
      T y; 
      T g; 
    };

    union {
      T z; 
      T b; 
    };

    union {
      T w; 
      T a; 
    };
  };

  using Vector2f = Vector<float, 2>;

  using Vector3f = Vector<float, 3>;

  using Vector4f = Vector<float, 4>;

  using Vector2d = Vector<double, 2>;

  using Vector3d = Vector<double, 3>;

  using Vector4d = Vector<double, 4>;

  using Vector2i = Vector<int, 2>;

  using Vector3i = Vector<int, 3>;

  using Vector4i = Vector<int, 4>;

  using Vector2u = Vector<unsigned, 2>;

  using Vector3u = Vector<unsigned, 3>;

  using Vector4u = Vector<unsigned, 4>;

  using Vector2z = Vector<std::size_t, 2>;

  using Vector3z = Vector<std::size_t, 3>;

  using Vector4z = Vector<std::size_t, 4>;

  using Vector2b = Vector<bool, 2>;

  using Vector3b = Vector<bool, 3>;

  using Vector4b = Vector<bool, 4>;

  template<typename T>
  using Color3 = Vector<T, 3>;

  template<typename T>
  using Color4 = Vector<T, 4>;

  using Color3f = Color3<float>;

  using Color4f = Color4<float>;

  using Color3d = Color3<double>;

  using Color4d = Color4<double>;

  using Color3u = Color3<uint8_t>;

  using Color4u = Color4<uint8_t>;



// MSVC does not like extern template
#ifndef _MSC_VER
  extern template struct GF_API Vector<float, 2>;
  extern template struct GF_API Vector<float, 3>;
  extern template struct GF_API Vector<float, 4>;

  extern template struct GF_API Vector<double, 2>;
  extern template struct GF_API Vector<double, 3>;
  extern template struct GF_API Vector<double, 4>;

  extern template struct GF_API Vector<int, 2>;
  extern template struct GF_API Vector<int, 3>;
  extern template struct GF_API Vector<int, 4>;

  extern template struct GF_API Vector<unsigned, 2>;
  extern template struct GF_API Vector<unsigned, 3>;
  extern template struct GF_API Vector<unsigned, 4>;

  extern template struct GF_API Vector<bool, 2>;
  extern template struct GF_API Vector<bool, 3>;
  extern template struct GF_API Vector<bool, 4>;

  extern template struct GF_API Vector<uint8_t, 3>;
  extern template struct GF_API Vector<uint8_t, 4>;
#endif

  template<typename T, std::size_t N>
  using Distance = T (*)(Vector<T, N>, Vector<T, N>);

  template<typename T>
  using Distance2 = Distance<T, 2>;

  template<typename T>
  using Distance3 = Distance<T, 3>;


  template<typename T, std::size_t N>
  inline
  void swap(Vector<T,N>& lhs, Vector<T,N>& rhs) noexcept {
    std::swap_ranges(lhs.begin(), lhs.end(), rhs.begin());
  }

  template<typename ... Types>
  constexpr
  auto vec(Types... values) -> Vector<std::common_type_t<Types...>, sizeof...(Types)> {
    static_assert(sizeof...(Types) > 0, "Vectors must have at least one coordinate");
    return { static_cast<std::common_type_t<Types...>>(values)... };
  }

#ifndef DOXYGEN_SHOULD_SKIP_THIS
}
#endif
}

#endif // GAME_VECTOR_H