/*
* Copyright (C) 2021 Christopher J. Howard
*
* This file is part of Antkeeper source code.
*
* Antkeeper source code is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Antkeeper source code is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Antkeeper source code. If not, see .
*/
#ifndef ANTKEEPER_MATH_VECTOR_HPP
#define ANTKEEPER_MATH_VECTOR_HPP
#include
#include
#include
#include
#include
#include
#include
#include
namespace math {
/**
* *n*-dimensional Euclidean vector.
*
* @tparam T Element type.
* @tparam N Number of elements.
*/
template
struct vector
{
/// Vector element data type.
typedef T element_type;
/// Number of elements.
static constexpr std::size_t element_count = N;
/// Array of vector elements.
element_type elements[N];
/**
* Returns a reference to the element at a given index.
*
* @param i Index of an element.
*
* @return Reference to the element at index @p i.
*/
/// @{
constexpr inline element_type& operator[](std::size_t i) noexcept
{
return elements[i];
}
constexpr inline const element_type& operator[](std::size_t i) const noexcept
{
return elements[i];
}
/// @}
/// Returns a reference to the first element.
/// @{
constexpr inline element_type& front() noexcept
{
return elements[0];
}
constexpr inline const element_type& front() const noexcept
{
return elements[0];
}
/// @}
/// Returns a reference to the last element.
/// @{
constexpr inline element_type& back() noexcept
{
return elements[N - 1];
}
constexpr inline const element_type& back() const noexcept
{
return elements[N - 1];
}
/// @}
/// Returns a reference to the first element.
/// @{
constexpr inline element_type& x() noexcept
{
static_assert(N > 0, "Vector does not contain an x element.");
return elements[0];
}
constexpr inline const element_type& x() const noexcept
{
static_assert(N > 0, "Vector does not contain an x element.");
return elements[0];
}
/// @}
/// Returns a reference to the second element.
/// @{
constexpr inline element_type& y() noexcept
{
static_assert(N > 1, "Vector does not contain a y element.");
return elements[1];
}
constexpr inline const element_type& y() const noexcept
{
static_assert(N > 1, "Vector does not contain a y element.");
return elements[1];
}
/// @}
/// Returns a reference to the third element.
/// @{
constexpr inline element_type& z() noexcept
{
static_assert(N > 2, "Vector does not contain a z element.");
return elements[2];
}
constexpr inline const element_type& z() const noexcept
{
static_assert(N > 2, "Vector does not contain a z element.");
return elements[2];
}
/// @}
/// Returns a pointer to the element array.
/// @{
constexpr inline element_type* data() noexcept
{
return elements;
};
constexpr inline const element_type* data() const noexcept
{
return elements;
};
/// @}
/// Returns an iterator to the first element.
/// @{
constexpr inline element_type* begin() noexcept
{
return elements;
}
constexpr inline const element_type* begin() const noexcept
{
return elements;
}
constexpr inline const element_type* cbegin() const noexcept
{
return elements;
}
/// @}
/// Returns an iterator to the element following the last element.
/// @{
constexpr inline element_type* end() noexcept
{
return elements + N;
}
constexpr inline const element_type* end() const noexcept
{
return elements + N;
}
constexpr inline const element_type* cend() const noexcept
{
return elements + N;
}
/// @}
/// Returns a reverse iterator to the first element of the reversed vector.
/// @{
constexpr inline std::reverse_iterator rbegin() noexcept
{
return std::reverse_iterator(elements + N);
}
constexpr inline std::reverse_iterator rbegin() const noexcept
{
return std::reverse_iterator(elements + N);
}
constexpr inline std::reverse_iterator crbegin() const noexcept
{
return std::reverse_iterator(elements + N);
}
/// @}
/// Returns a reverse iterator to the element following the last element of the reversed vector.
/// @{
constexpr inline std::reverse_iterator rend() noexcept
{
return std::reverse_iterator(elements);
}
constexpr inline std::reverse_iterator rend() const noexcept
{
return std::reverse_iterator(elements);
}
constexpr inline std::reverse_iterator crend() const noexcept
{
return std::reverse_iterator(elements);
}
/// @}
/// Returns the number of elements in the vector.
constexpr inline std::size_t size() const noexcept
{
return N;
};
/// @private
template
constexpr inline vector type_cast(std::index_sequence) const noexcept
{
return {static_cast(elements[I])...};
}
/**
* Type-casts the elements of this vector.
*
* @tparam U Target element type.
*
* @return Vector containing the type-casted elements.
*/
template
constexpr inline explicit operator vector() const noexcept
{
return type_cast(std::make_index_sequence{});
}
/// @private
template
constexpr inline vector size_cast(std::index_sequence) const noexcept
{
return {(I < N) ? elements[I] : T{0} ...};
}
/**
* Size-casts this vector to a vector with a different number of elements. Casting to a greater number of elements causes new elements to be set to `0`.
*
* @tparam M Target number of elements.
*
* @return Vector containing the type-casted elements.
*/
template
constexpr inline explicit operator vector() const noexcept
{
return size_cast(std::make_index_sequence{});
}
};
// Ensure vector is a POD type
static_assert(std::is_standard_layout>::value, "Vector is not a standard-layout type.");
static_assert(std::is_trivial>::value, "Vector is not a trivial type.");
static_assert(sizeof(vector) == sizeof(float) * 3, "Vector size is greater than the size of its elements.");
/// Vector with two elements.
template
using vector2 = vector;
/// Vector with three elements.
template
using vector3 = vector;
/// Vector with four elements.
template
using vector4 = vector;
/**
* Returns the absolute values of each element.
*
* @param x Input vector
* @return Absolute values of input vector elements.
*/
template
constexpr vector abs(const vector& x);
/**
* Adds two values.
*
* @param x First value.
* @param y Second value.
* @return Sum of the two values.
*/
/// @{
template
constexpr vector add(const vector& x, const vector& y);
template
constexpr vector add(const vector& x, T y);
/// @}
/**
* Checks if all elements of a boolean vector are `true`.
*
* @param x Vector to be tested for truth.
* @return `true` if all elements are `true`, `false` otherwise.
*/
template
constexpr bool all(const vector& x);
/**
* Checks if any elements of a boolean vector are `true`.
*
* @param x Vector to be tested for truth.
* @return `true` if any elements are `true`, `false` otherwise.
*/
template
constexpr bool any(const vector& x);
/**
* Reinterprets data as an *n*-dimensional vector of type `T`.
*
* @param data Data to reinterpret.
*/
template
constexpr vector& as_vector(T& data);
/**
* Performs a element-wise ceil operation.
*
* @param x Input vector
* @return Component-wise ceil of input vector.
*/
template
constexpr vector ceil(const vector& x);
/**
* Clamps the values of a vector's elements.
*
* @param x Vector to clamp.
* @param min_val Minimum value.
* @param max_val Maximum value.
* @return Clamped vector.
*/
/// @{
template
constexpr vector clamp(const vector& x, const vector& min_val, const vector& max_val);
template
constexpr vector clamp(const vector& x, T min_val, T max_val);
/// @}
/**
* Clamps the length of a vector.
*
* @param x Vector to clamp.
* @param max_length Maximum length.
* @return Length-clamped vector.
*/
template
vector clamp_length(const vector& x, T max_length);
/**
* Calculate the cross product of two vectors.
*
* @param x First vector.
* @param y Second vector.
* @return Cross product of the two vectors.
*/
template
constexpr vector cross(const vector& x, const vector& y);
/**
* Calculates the distance between two points.
*
* @param p0 First of two points.
* @param p1 Second of two points.
* @return Distance between the two points.
*/
template
T distance(const vector& p0, const vector& p1);
/**
* Calculates the squared distance between two points. The squared distance can be calculated faster than the distance because a call to `std::sqrt` is saved.
*
* @param p0 First of two points.
* @param p1 Second of two points.
* @return Squared distance between the two points.
*/
template
constexpr T distance_squared(const vector& p0, const vector& p1);
/**
* Divides a vector by a value.
*
* @param x First value.
* @param y Second value.
* @return Result of the division.
*/
/// @{
template
constexpr vector div(const vector& x, const vector& y);
template
constexpr vector div(const vector& x, T y);
/// @}
/**
* Calculates the dot product of two vectors.
*
* @param x First vector.
* @param y Second vector.
* @return Dot product of the two vectors.
*/
template
constexpr T dot(const vector& x, const vector& y);
/**
* Compares two vectors for equality
*
* @param x First vector.
* @param y Second vector.
* @return Boolean vector containing the result of the element comparisons.
*/
template
constexpr vector equal(const vector& x, const vector& y);
/**
* Performs a element-wise floor operation.
*
* @param x Input vector
* @return Component-wise floor of input vector.
*/
template
constexpr vector floor(const vector& x);
/**
* Performs a multiply-add operation.
*
* @param x Input vector
* @param y Value to multiply.
* @param z Value to add.
*
* @return Vector containing the multiply-add results.
*/
/// @{
template
constexpr vector fma(const vector& x, const vector& y, const vector& z);
template
constexpr vector fma(const vector& x, T y, T z);
/// @}
/**
* Returns a vector containing the fractional part of each element.
*
* @param x Input vector
* @return Fractional parts of input vector.
*/
template
constexpr vector fract(const vector& x);
/**
* Performs a element-wise greater-than comparison of two vectors.
*
* @param x First vector.
* @param y Second vector.
* @return Boolean vector containing the result of the element comparisons.
*/
template
constexpr vector greater_than(const vector& x, const vector& y);
/**
* Performs a element-wise greater-than or equal-to comparison of two vectors.
*
* @param x First vector.
* @param y Second vector.
* @return Boolean vector containing the result of the element comparisons.
*/
template
constexpr vector greater_than_equal(const vector& x, const vector& y);
/**
* Calculates the length of a vector.
*
* @param x Vector of which to calculate the length.
* @return Length of the vector.
*/
template
T length(const vector& x);
/**
* Calculates the squared length of a vector. The squared length can be calculated faster than the length because a call to `std::sqrt` is saved.
*
* @param x Vector of which to calculate the squared length.
* @return Squared length of the vector.
*/
template
constexpr T length_squared(const vector& x);
/**
* Performs a element-wise less-than comparison of two vectors.
*
* @param x First vector.
* @param y Second vector.
* @return Boolean vector containing the result of the element comparisons.
*/
template
constexpr vector less_than(const vector& x, const vector& y);
/**
* Performs a element-wise less-than or equal-to comparison of two vectors.
*
* @param x First vector.
* @param y Second vector.
* @return Boolean vector containing the result of the element comparisons.
*/
template
constexpr vector less_than_equal(const vector& x, const vector& y);
/**
* Returns the value of the greatest element in a vector.
*
* @param x Input vector.
*
* @return Value of the greatest element in the input vector.
*/
template
constexpr T max(const vector& x);
/**
* Returns the value of the smallest element in a vector.
*
* @param x Input vector.
*
* @return Value of the smallest element in the input vector.
*/
template
constexpr T min(const vector& x);
/**
* Calculates the element-wise remainder of the division operation `x / y`.
*
* @param x First vector.
* @param y Second vector.
* @return Remainders of `x / y`.
*/
/// @{
template
constexpr vector mod(const vector& x, const vector& y);
template
constexpr vector mod(const vector& x, T y);
/// @}
/**
* Multiplies two values.
*
* @param x First value.
* @param y Second value.
* @return Product of the two values.
*/
/// @{
template
constexpr vector mul(const vector& x, const vector& y);
template
constexpr vector mul(const vector& x, T y);
/// @}
/**
* Negates a vector.
*
* @param x Vector to negate.
* @return Negated vector.
*/
template
constexpr vector negate(const vector& x);
/**
* Calculates the unit vector in the same direction as the original vector.
*
* @param x Vector to normalize.
* @return Normalized vector.
*/
template
vector normalize(const vector& x);
/**
* Logically inverts a boolean vector.
*
* @param x Vector to be inverted.
* @return Logically inverted vector.
*/
template
constexpr vector not(const vector& x);
/**
* Compares two vectors for inequality
*
* @param x First vector.
* @param y Second vector.
* @return Boolean vector containing the result of the element comparisons.
*/
template
constexpr vector not_equal(const vector& x, const vector& y);
/**
* Resizes a vector. Any new elements will be set to `0`.
*
* @tparam M Target number of elements.
*
* @param x Vector to resize.
*
* @return Resized vector.
*/
template
constexpr vector resize(const vector& x);
/**
* Performs a element-wise round operation.
*
* @param x Input vector
* @return Component-wise round of input vector.
*/
template
constexpr vector round(const vector& x);
/**
* Returns a vector containing the signs of each element.
*
* @param x Input vector
* @return Signs of input vector elements.
*/
template
constexpr vector sign(const vector& x);
/**
* Subtracts a value by another value.
*
* @param x First value.
* @param y Second value.
* @return Difference between the two values.
*/
/// @{
template
constexpr vector sub(const vector& x, const vector& y);
template
constexpr vector sub(const vector& x, T y);
/// @}
/**
* Calculates the sum of all elements in a vector.
*
* @param x Vector to sum.
* @return Sum of the vector's elements.
*/
template
constexpr T sum(const vector& x);
/**
* Makes an *m*-dimensional vector by rearranging and/or duplicating elements of an *n*-dimensional vector.
*
* @tparam Indices List of indices of elements in @p x.
* @tparam T Vector element type.
* @tparam N Number of dimensions in @p x.
*
* @param x Vector to swizzle.
*
* @return Vector containing elements from @p x in the order specified by @p Indices. The size of the returned vector is equivalent to the number of indices in @p Indices.
*/
template
constexpr vector swizzle(const vector& x);
/**
* Performs a element-wise trunc operation.
*
* @param x Input vector
* @return Component-wise trunc of input vector.
*/
template
constexpr vector trunc(const vector& x);
/**
* Types casts each vector element and returns a vector of the casted type.
*
* @tparam U Target vector element type.
* @tparam T Source vector element type.
* @tparam N Number of dimensions.
* @param x Vector to type cast.
*
* @return Type-casted vector.
*/
template
constexpr vector type_cast(const vector& x);
/// @private
template
constexpr inline vector abs(const vector& x, std::index_sequence)
{
return {std::abs(x[I])...};
}
template
constexpr inline vector abs(const vector& x)
{
return abs(x, std::make_index_sequence{});
}
/// @private
template
constexpr inline vector add(const vector& x, const vector& y, std::index_sequence)
{
return {(x[I] + y[I])...};
}
template
constexpr inline vector add(const vector& x, const vector& y)
{
return add(x, y, std::make_index_sequence{});
}
/// @private
template
constexpr inline vector add(const vector& x, T y, std::index_sequence)
{
return {(x[I] + y)...};
}
template
constexpr inline vector add(const vector& x, T y)
{
return add(x, y, std::make_index_sequence{});
}
/// @private
template
constexpr inline bool all(const vector& x, std::index_sequence)
{
return (x[I] && ...);
}
template
constexpr inline bool all(const vector& x)
{
return all(x, std::make_index_sequence{});
}
/// @private
template
constexpr inline bool any(const vector& x, std::index_sequence)
{
return (x[I] || ...);
}
template
constexpr inline bool any(const vector& x)
{
return any(x, std::make_index_sequence{});
}
template
constexpr inline vector& as_vector(T& data)
{
static_assert(std::is_pod>::value);
return reinterpret_cast&>(data);
}
/// @private
template
constexpr inline vector ceil(const vector& x, std::index_sequence)
{
return {std::ceil(x[I])...};
}
template
constexpr inline vector ceil(const vector& x)
{
static_assert(std::is_floating_point::value);
return ceil(x, std::make_index_sequence{});
}
/// @private
template
constexpr inline vector clamp(const vector& x, const vector& min_val, const vector& max_val, std::index_sequence)
{
return {std::min(max_val[I], std::max(min_val[I], x[I]))...};
}
template
constexpr inline vector clamp(const vector& x, const vector