Vector.h

/*
 * Gamedev Framework (gf)
 * Copyright (C) 2016-2017 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"

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;

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

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

    Vector(std::initializer_list<T> list)
    {
      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)
    {
      static_assert(std::is_convertible<U,T>::value, "");
      std::transform(data, data + N, other.data, [](U val) { return static_cast<T>(val); });
    }

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

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

    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];
    }

    T data[N];
  };

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

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

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

    constexpr Vector(T x, T y)
    : data{ x, y }
    {

    }

    Vector(const Vector& other) = default;


    template<typename U>
    Vector(const Vector<U, 2>& other)
    : x(other.x)
    , y(other.y)
    {

    }

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

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


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

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

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

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

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

    union {
      T data[2]; 
      struct {
        T x; 
        T y; 
      };
      struct {
        T u; 
        T v; 
      };
      struct {
        T s; 
        T t; 
      };
      struct {
        T width; 
        T height; 
      };
      struct {
        T col; 
        T row; 
      };
    };
  };

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

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

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

    constexpr Vector(T x, T y, T z)
    : data{ x, y, z }
    {

    }

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

    }

    Vector(const Vector& other) = default;


    template<typename U>
    Vector(const Vector<U, 3>& other)
    : x(other.x)
    , y(other.y)
    , z(other.z)
    {

    }

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

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


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

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

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

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

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

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

    union {
      T data[3]; 
      struct {
        T x; 
        T y; 
        T z; 
      };
      struct {
        T r; 
        T g; 
        T b; 
      };
      Vector<T, 2> xy; 
    };
  };

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

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

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

    constexpr Vector(T x, T y, T z, T w)
    : data{ x, y, z, w }
    {

    }

    Vector(const Vector& other) = default;


    template<typename U>
    Vector(const Vector<U, 4>& other)
    : x(other.x)
    , y(other.y)
    , z(other.z)
    , w(other.w)
    {

    }

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

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


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

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

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

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

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

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

    union {
      T data[4]; 
      struct {
        T x; 
        T y; 
        T z; 
        T w; 
      };
      struct {
        T r; 
        T g; 
        T b; 
        T a; 
      };
      Vector<T, 2> xy; 
      Vector<T, 3> xyz; 
      Vector<T, 3> rgb; 
    };
  };

  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>;

  using Color3f = Vector<float, 3>;

  using Color4f = Vector<float, 4>;

  using Color3u = Vector<uint8_t, 3>;

  using Color4u = Vector<uint8_t, 4>;

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

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

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

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

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

  extern template struct Vector<uint8_t, 3>;
  extern template struct 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>;

#ifndef DOXYGEN_SHOULD_SKIP_THIS
}
#endif
}

#endif // GAME_VECTOR_H