vector.h

Go to the documentation of this file.

// =====================================================================================================================
//  fennec, a free and open source game engine
//  Copyright © 2025  Medusa Slockbower
//
//  This program 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.
//
//  This program 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 this program.  If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
 
 
#ifndef FENNEC_MATH_VECTOR_H
#define FENNEC_MATH_VECTOR_H
 
 
#include <fennec/containers/initializer_list.h>
#include <fennec/math/detail/_fwd.h>
 
#include <fennec/math/vector_base.h>
#include <fennec/math/vector_traits.h>
 
#include <fennec/lang/conditional_types.h>
#include <fennec/lang/type_traits.h>
#include <fennec/lang/utility.h>
 
namespace fennec
{
 
template<typename ScalarT, size_t SizeV>
using vec = decltype(detail::_gen_vector<vector, ScalarT>(make_index_metasequence<SizeV>{}));
 
 
template<typename ScalarT>
using tvec2 = vec<ScalarT, 2>;
 
template<typename ScalarT>
using tvec3 = vec<ScalarT, 3>;
 
template<typename ScalarT>
using tvec4 = vec<ScalarT, 4>;
 
 
using bvec2 = tvec2<bool_t>; 
using bvec3 = tvec3<bool_t>; 
using bvec4 = tvec4<bool_t>; 
 
using ivec2 = tvec2<int32_t>; 
using ivec3 = tvec3<int32_t>; 
using ivec4 = tvec4<int32_t>; 
 
using uvec2 = tvec2<uint32_t>; 
using uvec3 = tvec3<uint32_t>; 
using uvec4 = tvec4<uint32_t>; 
 
using vec2 = tvec2<float_t>;
using vec3 = tvec3<float_t>;
using vec4 = tvec4<float_t>;
 
using dvec2 = tvec2<double_t>;
using dvec3 = tvec3<double_t>;
using dvec4 = tvec4<double_t>;
 
 
template<typename ScalarT, size_t... IndicesV> requires(is_scalar_v<ScalarT>)
struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
{
// Assertions ==========================================================================================================
 
    static_assert(is_arithmetic_v<ScalarT>);
 
 
// Forward Defs ========================================================================================================
 
 
    using base_type = detail::vector_base_type<ScalarT, sizeof...(IndicesV)>;
 
    using base_type::data;
 
    using scalar_t = ScalarT;
 
    using vector_t = vector;
 
    // Size Aliases
    static constexpr size_t dimension = sizeof...(IndicesV); 
    static constexpr size_t num_components = sizeof...(IndicesV); 
    static constexpr size_t size = sizeof...(IndicesV); 
    static constexpr size_t N = sizeof...(IndicesV); 
 
    using decay_t = conditional_t<N == 1, scalar_t, vector_t>;
 
 
 
// Constructors ========================================================================================================
 
 
    constexpr vector() {
        data = { 0 };
    }
 
 
    constexpr vector(const vector_t& x) {
        data = x.data;
    }
 
 
    constexpr vector(vector_t&& x) noexcept {
        data = fennec::move(x.data);
    }
 
 
    explicit constexpr vector(scalar_t s) {
        ((data[IndicesV] = s), ...);
    }
 
 
    explicit constexpr vector(int_t s) requires(not is_same_v<ScalarT, int_t>) {
        if constexpr (N == 1) data[0] = ScalarT(s);
        else ((data[IndicesV] = ScalarT(s)), ...);
    }
 
 
    explicit constexpr vector(double_t s) requires(not is_same_v<ScalarT, double_t>) {
        if constexpr (N == 1) data[0] = ScalarT(s);
        else ((data[IndicesV] = ScalarT(s)), ...);
    }
 
 
    // This is not in the GLSL spec, I don't remember writing it, and it's behaviour is strange.
    //template<typename OScalarT>
    //explicit constexpr vector(const vector<OScalarT, IndicesV...>& v)
    //: data() {
    //  ((data[IndicesV] = ScalarT(v[IndicesV])), ...);
    //}
 
 
    template<typename OScalarT, size_t MoreIndicesStartV, size_t... MoreIndicesV>
    explicit constexpr vector(const vector<OScalarT, IndicesV..., MoreIndicesStartV, MoreIndicesV...>& v) {
        ((data[IndicesV] = ScalarT(v[IndicesV])), ...);
    }
 
 
    template<typename SwizzleDataT, typename SwizzleScalarT, size_t... SwizzleIndicesV>
    explicit constexpr vector(const detail::swizzle_storage<SwizzleDataT, SwizzleScalarT, SwizzleIndicesV...>& swizzle) {
        ((data[IndicesV] = ScalarT(swizzle[IndicesV])), ...);
    }
 
 
    template<typename... ArgsT> requires(total_component_count_v<ArgsT...> == N)
    explicit constexpr vector(ArgsT&&... args) {
        vector::_construct<0>(args...);
    }
 
    constexpr vector(initializer_list<ScalarT> init) {
        size_t i = 0;
        for (ScalarT x : init) {
            data[i++] = x;
        }
    }
 
    template<typename OScalarT>
    constexpr vector(initializer_list<OScalarT> init) {
        size_t i = 0;
        for (OScalarT x : init) {
            data[i++] = ScalarT(x);
        }
    }
 
 
 
// Public Member Functions =============================================================================================
 
 
    decay_t decay() {
        return static_cast<const decay_t&>(*this);
    }
 
 
 
// Access operators ====================================================================================================
 
 
    constexpr scalar_t& operator[](size_t i) {
        return data[i];
    }
 
    constexpr scalar_t operator[](size_t i) const {
        return data[i];
    }
 
 
 
// Assignment operators ================================================================================================
 
 
    constexpr vector_t& operator=(const vector_t& rhs) {
        return ((data[IndicesV] = rhs[IndicesV]), ..., *this);
    }
 
    constexpr vector_t& operator=(vector_t&& rhs) noexcept {
        return ((data[IndicesV] = fennec::move(rhs[IndicesV])), ..., *this);
    }
 
 
 
// Comparison Operators ================================================================================================
 
 
    constexpr bool_t operator==(const vector_t& rhs) const {
        return ((data[IndicesV] == rhs.data[IndicesV]) && ...);
    }
 
    constexpr bool_t operator!=(const vector_t& rhs) const {
        return ((data[IndicesV] != rhs.data[IndicesV]) || ...);
    }
 
 
 
// Scalar-Vector Arithmetic operators ==================================================================================
 
 
    constexpr friend vector_t operator+(scalar_t lhs, const vector_t& rhs) {
        return vector_t((lhs + rhs[IndicesV])...);
    }
 
    constexpr friend vector_t operator-(scalar_t lhs, const vector_t& rhs) {
        return vector_t((lhs - rhs[IndicesV])...);
    }
 
    constexpr friend vector_t operator*(scalar_t lhs, const vector_t& rhs) {
        return vector_t((lhs * rhs[IndicesV])...);
    }
 
    constexpr friend vector_t operator/(scalar_t lhs, const vector_t& rhs) {
        return vector_t((lhs / rhs[IndicesV])...);
    }
 
    constexpr friend vector_t operator%(scalar_t lhs, const vector_t& rhs) requires(is_integral_v<scalar_t>) {
        return vector_t((lhs % rhs[IndicesV])...);
    }
 
 
// Vector-Scalar Arithmetic operators ==================================================================================
 
 
    constexpr friend vector_t operator+(const vector_t& lhs, scalar_t rhs) {
        return vector_t((lhs[IndicesV] + rhs)...);
    }
 
    constexpr friend vector_t operator-(const vector_t& lhs, scalar_t rhs) {
        return vector_t((lhs[IndicesV] - rhs)...);
    }
 
    constexpr friend vector_t operator*(const vector_t& lhs, scalar_t rhs) {
        return vector_t((lhs[IndicesV] * rhs)...);
    }
 
    constexpr friend vector_t operator/(const vector_t& lhs, scalar_t rhs) {
        return vector((lhs[IndicesV] / rhs)...);
    }
 
    constexpr friend vector_t operator%(const vector_t& lhs, scalar_t rhs) requires(is_integral_v<scalar_t>) {
        return vector((lhs[IndicesV] % rhs)...);
    }
 
 
// Vector-Scalar Arithmetic Assignment operators =======================================================================
 
 
    constexpr friend vector_t& operator+=(vector_t& lhs, scalar_t rhs) {
        return ((lhs[IndicesV] += rhs), ..., lhs);
    }
 
    constexpr friend vector_t& operator-=(vector_t& lhs, scalar_t rhs) {
        return ((lhs[IndicesV] -= rhs), ..., lhs);
    }
 
    constexpr friend vector_t& operator*=(vector_t& lhs, scalar_t rhs) {
        return ((lhs[IndicesV] *= rhs), ..., lhs);
    }
 
    constexpr friend vector_t& operator/=(vector_t& lhs, scalar_t rhs) {
        return ((lhs[IndicesV] /= rhs), ..., lhs);
    }
 
    constexpr friend vector_t& operator%=(vector_t& lhs, scalar_t rhs) requires(is_integral_v<scalar_t>) {
        return ((lhs[IndicesV] %= rhs), ..., lhs);
    }
 
 
// Vector-Vector Arithmetic operators ==================================================================================
 
 
    constexpr friend vector_t operator-(const vector_t& x) {
        return vector((-x[IndicesV])...);
    }
 
    constexpr friend vector_t operator+(const vector_t& lhs, const vector_t& rhs) {
        return vector((lhs[IndicesV] + rhs[IndicesV])...);
    }
 
    constexpr friend vector_t operator-(const vector_t& lhs, const vector_t& rhs) {
        return vector((lhs[IndicesV] - rhs[IndicesV])...);
    }
 
    constexpr friend vector_t operator*(const vector_t& lhs, const vector_t& rhs) {
        return vector((lhs[IndicesV] * rhs[IndicesV])...);
    }
 
    constexpr friend vector_t operator/(const vector_t& lhs, const vector_t& rhs) {
        return vector((lhs[IndicesV] / rhs[IndicesV])...);
    }
 
    constexpr friend vector_t operator%(const vector_t& lhs, const vector_t& rhs) requires(is_integral_v<scalar_t>) {
        return vector((lhs[IndicesV] % rhs[IndicesV])...);
    }
 
 
// Vector-Vector Arithmetic Assignment operators =======================================================================
 
 
    constexpr friend vector_t& operator+=(vector_t& lhs, const vector_t& rhs) {
        return ((lhs[IndicesV] += rhs[IndicesV]), ..., lhs);
    }
 
    constexpr friend vector_t& operator-=(vector_t& lhs, const vector_t& rhs) {
        return ((lhs[IndicesV] -= rhs[IndicesV]), ..., lhs);
    }
 
    constexpr friend vector_t& operator*=(vector_t& lhs, const vector_t& rhs) {
        return ((lhs[IndicesV] *= rhs[IndicesV]), ..., lhs);
    }
 
    constexpr friend vector_t& operator/=(vector_t& lhs, const vector_t& rhs) {
        return ((lhs[IndicesV] /= rhs[IndicesV]), ..., lhs);
    }
 
    constexpr friend vector_t& operator%=(vector_t& lhs, const vector_t& rhs) requires(is_integral_v<scalar_t>) {
        return ((lhs[IndicesV] %= rhs[IndicesV]), ..., lhs);
    }
 
 
// Boolean Operators ===================================================================================================
 
 
    constexpr friend vector_t operator!(const vector_t& x) {
        return vector_t(!x[IndicesV]...);
    }
 
    constexpr friend vector_t operator&&(const vector_t& lhs, scalar_t rhs) requires(is_bool_v<scalar_t>) {
        return vector_t((lhs[IndicesV] && rhs)...);
    }
 
    constexpr friend vector_t operator&&(const vector_t& lhs, const vector_t& rhs) requires(is_bool_v<scalar_t>) {
        return vector_t((lhs[IndicesV] && rhs[IndicesV])...);
    }
 
    constexpr friend vector_t operator||(const vector_t& lhs, scalar_t rhs) requires(is_bool_v<scalar_t>) {
        return vector_t((lhs[IndicesV] || rhs)...);
    }
 
    constexpr friend vector_t operator||(const vector_t& lhs, const vector_t& rhs) requires(is_bool_v<scalar_t>) {
        return vector_t((lhs[IndicesV] || rhs[IndicesV])...);
    }
 
 
// Bitwise Operators ===================================================================================================
 
 
    constexpr friend vector_t operator&(scalar_t rhs, const vector_t& lhs) requires(is_integral_v<scalar_t>) {
        return vector_t((lhs[IndicesV] & rhs)...);
    }
 
    constexpr friend vector_t operator&(const vector_t& lhs, scalar_t rhs) requires(is_integral_v<scalar_t>) {
        return vector_t((lhs[IndicesV] & rhs)...);
    }
 
    constexpr friend vector_t operator&=(vector_t& lhs, scalar_t rhs) requires(is_integral_v<scalar_t>) {
        return ((lhs[IndicesV] &= rhs), ..., lhs);
    }
 
    constexpr friend vector_t operator&(const vector_t& lhs, const vector_t& rhs) requires(is_integral_v<
        scalar_t>) {
        return vector_t((lhs[IndicesV] & rhs[IndicesV])...);
    }
 
    constexpr friend vector_t operator&=(vector_t& lhs, const vector_t& rhs) requires(is_integral_v<scalar_t>) {
        return ((lhs[IndicesV] &= rhs[IndicesV]), ..., lhs);
    }
 
 
    constexpr friend vector_t operator|(scalar_t rhs, const vector_t& lhs) requires(is_integral_v<scalar_t>) {
        return vector_t((lhs[IndicesV] | rhs)...);
    }
 
    constexpr friend vector_t operator|(const vector_t& lhs, scalar_t rhs) requires(is_integral_v<scalar_t>) {
        return vector_t((lhs[IndicesV] | rhs)...);
    }
 
    constexpr friend vector_t operator|=(vector_t& lhs, scalar_t rhs) requires(is_integral_v<scalar_t>) {
        return ((lhs[IndicesV] |= rhs), ..., lhs);
    }
 
    constexpr friend vector_t operator|(const vector_t& lhs, const vector_t& rhs) requires(is_integral_v<
        scalar_t>) {
        return vector_t((lhs[IndicesV] | rhs[IndicesV])...);
    }
 
    constexpr friend vector_t operator|=(vector_t& lhs, const vector_t& rhs) requires(is_integral_v<scalar_t>) {
        return ((lhs[IndicesV] |= rhs[IndicesV]), ..., lhs);
    }
 
 
    constexpr friend vector_t operator^(scalar_t lhs, const vector_t& rhs) requires(is_integral_v<scalar_t>) {
        return vector_t((lhs ^ rhs[IndicesV])...);
    }
 
    constexpr friend vector_t operator^(const vector_t& lhs, scalar_t rhs) requires(is_integral_v<scalar_t>) {
        return vector_t((lhs[IndicesV] ^ rhs)...);
    }
 
    constexpr friend vector_t operator^=(vector_t& lhs, scalar_t rhs) requires(is_integral_v<scalar_t>) {
        return ((lhs[IndicesV] ^= rhs), ..., lhs);
    }
 
    constexpr friend vector_t operator^(const vector_t& lhs, const vector_t& rhs) requires(is_integral_v<
        scalar_t>) {
        return vector_t((lhs[IndicesV] ^ rhs[IndicesV])...);
    }
 
    constexpr friend vector_t operator^=(vector_t& lhs, const vector_t& rhs) requires(is_integral_v<scalar_t>) {
        return ((lhs[IndicesV] ^= rhs[IndicesV]), ..., lhs);
    }
 
 
    constexpr friend vector_t operator<<(scalar_t lhs, const vector_t& rhs) requires(is_integral_v<scalar_t>) {
        return vector_t((lhs << rhs[IndicesV])...);
    }
 
    constexpr friend vector_t operator<<(const vector_t& lhs, scalar_t rhs) requires(is_integral_v<scalar_t>) {
        return vector_t((lhs[IndicesV] << rhs)...);
    }
 
    constexpr friend vector_t operator<<=(vector_t& lhs, scalar_t rhs) requires(is_integral_v<scalar_t>) {
        return ((lhs[IndicesV] <<= rhs), ..., lhs);
    }
 
    constexpr friend vector_t operator<<(const vector_t& lhs, const vector_t& rhs) requires(is_integral_v<scalar_t>) {
        return vector_t((lhs[IndicesV] << rhs[IndicesV])...);
    }
 
    constexpr friend vector_t operator<<=(vector_t& lhs, const vector_t& rhs) requires(is_integral_v<scalar_t>) {
        return ((lhs[IndicesV] <<= rhs[IndicesV]), ..., lhs);
    }
 
 
    constexpr friend vector_t operator>>(scalar_t lhs, const vector_t& rhs) requires(is_integral_v<scalar_t>) {
        return vector_t((lhs >> rhs[IndicesV])...);
    }
 
    constexpr friend vector_t operator>>(const vector_t& lhs, scalar_t rhs) requires(is_integral_v<scalar_t>) {
        return vector_t((lhs[IndicesV] >> rhs)...);
    }
 
    constexpr friend vector_t operator>>=(vector_t& lhs, scalar_t rhs) requires(is_integral_v<scalar_t>) {
        return ((lhs[IndicesV] >>= rhs), ..., lhs);
    }
 
    constexpr friend vector_t operator>>(const vector_t& lhs, const vector_t& rhs) requires(is_integral_v<scalar_t>) {
        return vector_t((lhs[IndicesV] >> rhs[IndicesV])...);
    }
 
    constexpr friend vector_t operator>>=(vector_t& lhs, const vector_t& rhs) requires(is_integral_v<scalar_t>) {
        return ((lhs[IndicesV] >>= rhs[IndicesV]), ..., lhs);
    }
 
 
 
// Helpers =============================================================================================================
 
private:
    template<size_t IndexV = 0, typename HeadT, typename... TailT>
    constexpr void _construct(HeadT&& head, TailT&&... rest) {
        vector::_insert<IndexV>(fennec::forward<HeadT>(head));
 
        if constexpr (sizeof...(TailT) > 0)
            vector::_construct<IndexV + component_count_v<HeadT>>(fennec::forward<TailT>(rest)...);
    }
 
    template<size_t OffsetV>
    constexpr void _insert(const ScalarT& x) {
        data[OffsetV] = x;
    }
 
    template<size_t OffsetV, typename OScalarT>
    constexpr void _insert(const OScalarT& x) {
        data[OffsetV] = ScalarT(x);
    }
 
    template<size_t OffsetV = 0, typename OScalarT, size_t... OIndicesV>
    constexpr void _insert(const vector<OScalarT, OIndicesV...>& vec) {
        ((data[OffsetV + OIndicesV] = fennec::forward<OScalarT>(vec[OIndicesV])), ...);
    }
 
    template<size_t OffsetV = 0, typename OVectorT, typename ODataT, typename OScalarT, size_t... OIndicesV>
    constexpr void _insert(const swizzle<OVectorT, ODataT, OScalarT, OIndicesV...>& vec) {
        size_t i = 0;
        ((data[OffsetV + (i++)] = vec.data[OIndicesV]), ...);
    }
};
 
}
 
#endif // FENNEC_MATH_VECTOR_H