mal-math
C++20 mathematics library.
•All Classes Namespaces Files Functions Variables Typedefs Concepts
vec3.inl
Go to the documentation of this file.
1#pragma once
2#include "vec3.hpp"
3namespace mal_math
4{
5 template <Primitive T>
6 template <Primitive U>
7 constexpr vec<3, T>::vec(U value) { x = y = z = static_cast<T>(value); }
8 template <Primitive T>
9 template <Primitive A, Primitive B, Primitive C>
10 constexpr vec<3, T>::vec(A a, B b, C c)
11 {
12 x = static_cast<T>(a);
13 y = static_cast<T>(b);
14 z = static_cast<T>(c);
15 }
16 template <Primitive T>
17 template <typename... U>
18 constexpr vec<3, T>::vec(U... data)
19 {
20 static_assert(get_parameter_pack_size<U...>() == size,
21 "You have provided wrong amount of data");
22 unpack_data(0, data...);
23 }
24 template <Primitive T>
25 constexpr void vec<3, T>::reset() noexcept
26 {
27 x = y = z = 0;
28 }
29
30 template <Primitive T>
31 [[nodiscard]] constexpr vec<3, T> const &vec<3, T>::operator+() const noexcept
32 {
33 return *this;
34 }
35 template <Primitive T>
36 [[nodiscard]] constexpr vec<3, T> vec<3, T>::operator-() const noexcept
37 {
38 return vec<3, T>(-x, -y, -z);
39 }
40
41 template <Primitive T>
42 template <Primitive U>
43 constexpr vec<3, T> &vec<3, T>::operator+=(U const value) noexcept
44 {
45 x = static_cast<T>(x + value);
46 y = static_cast<T>(y + value);
47 z = static_cast<T>(z + value);
48 return *this;
49 }
50 template <Primitive T>
51 template <Primitive U>
52 constexpr vec<3, T> &vec<3, T>::operator-=(U const value) noexcept
53 {
54 x = static_cast<T>(x - value);
55 y = static_cast<T>(y - value);
56 z = static_cast<T>(z - value);
57 return *this;
58 }
59 template <Primitive T>
60 template <Primitive U>
61 constexpr vec<3, T> &vec<3, T>::operator*=(U const value) noexcept
62 {
63 x = static_cast<T>(x * value);
64 y = static_cast<T>(y * value);
65 z = static_cast<T>(z * value);
66 return *this;
67 }
68 template <Primitive T>
69 template <Primitive U>
70 constexpr vec<3, T> &vec<3, T>::operator/=(U const value) noexcept
71 {
72 x = static_cast<T>(x / value);
73 y = static_cast<T>(y / value);
74 z = static_cast<T>(z / value);
75 return *this;
76 }
77 template <Primitive T>
78 template <Primitive U>
79 constexpr vec<3, T> &vec<3, T>::operator%=(U const value) noexcept
80 {
81 x = static_cast<T>(x % value);
82 y = static_cast<T>(y % value);
83 z = static_cast<T>(z % value);
84 return *this;
85 }
86
87 template <Primitive T>
88 template <AnyVec U>
89 constexpr vec<3, T> &vec<3, T>::operator+=(U const &other) noexcept requires(size == U::size)
90 {
91 x = static_cast<T>(x + other.x);
92 y = static_cast<T>(y + other.y);
93 z = static_cast<T>(z + other.z);
94 return *this;
95 }
96 template <Primitive T>
97 template <AnyVec U>
98 constexpr vec<3, T> &vec<3, T>::operator-=(U const &other) noexcept requires(size == U::size)
99 {
100 x = static_cast<T>(x - other.x);
101 y = static_cast<T>(y - other.y);
102 z = static_cast<T>(z - other.z);
103 return *this;
104 }
105 template <Primitive T>
106 template <AnyVec U>
107 constexpr vec<3, T> &vec<3, T>::operator*=(U const &other) noexcept requires(size == U::size)
108 {
109 x = static_cast<T>(x * other.x);
110 y = static_cast<T>(y * other.y);
111 z = static_cast<T>(z * other.z);
112 return *this;
113 }
114 template <Primitive T>
115 template <AnyVec U>
116 constexpr vec<3, T> &vec<3, T>::operator/=(U const &other) noexcept requires(size == U::size)
117 {
118 x = static_cast<T>(x / other.x);
119 y = static_cast<T>(y / other.y);
120 z = static_cast<T>(z / other.z);
121 return *this;
122 }
123
124 template <Primitive T>
125 template <AnyVec U>
126 constexpr vec<3, T> &vec<3, T>::operator%=(U const &other) noexcept requires(size == U::size)
127 {
128 x = static_cast<T>(x % other.x);
129 y = static_cast<T>(y % other.y);
130 z = static_cast<T>(z % other.z);
131 return *this;
132 }
133 template <Primitive T>
134 [[nodiscard]] constexpr T &vec<3, T>::operator[](size_t i)
135 {
136 assert(i < size);
137 return data[i];
138 }
139 template <Primitive T>
140 [[nodiscard]] constexpr T const &vec<3, T>::operator[](size_t i) const
141 {
142 assert(i < size);
143 return data[i];
144 }
145
146 template <Primitive T>
147 template <Primitive _> // primitives
148 constexpr size_t vec<3, T>::get_parameter_pack_size()
149 {
150 return 1;
151 }
152 template <Primitive T>
153 template <class V> // vectors
154 constexpr size_t vec<3, T>::get_parameter_pack_size()
155 {
156 return V::size;
157 }
158 template <Primitive T>
159 template <typename A, typename B, typename... C>
160 constexpr size_t vec<3, T>::get_parameter_pack_size()
161 {
162 return get_parameter_pack_size<A>() + get_parameter_pack_size<B, C...>();
163 }
164
165 template <Primitive T>
166 template <Primitive U> // primitives
167 constexpr void vec<3, T>::unpack_data(size_t offset, U u)
168 {
169 data[offset] = static_cast<T>(u);
170 }
171 template <Primitive T>
172 template <class V> // vectors
173 constexpr void vec<3, T>::unpack_data(size_t offset, V vec)
174 {
175 for (size_t i = 0; i < V::size; i++)
176 {
177 data[offset + i] = static_cast<T>(vec[i]);
178 }
179 }
180 template <Primitive T>
181 template <typename A, typename B, typename... C>
182 constexpr void vec<3, T>::unpack_data(size_t offset, A a, B b, C... c)
183 {
184 unpack_data(offset, a);
185 offset += get_parameter_pack_size<A>();
186 unpack_data(offset, b, c...);
187 }
188
189 template <Primitive T, Primitive U>
190 constexpr vec<3, T> cross(vec<3, T> const &left, vec<3, U> const &right)
191 {
192 return vec<3, T>{
193 left.y *right.z - right.y * left.z,
194 left.z *right.x - right.z * left.x,
195 left.x *right.y - right.x * left.y};
196 }
197} // namespace mal_math
mal_math
Contains mathematical utility functions and classes.
mal_math::cross
constexpr vec< 3, T > cross(qua< T > const &left, vec< 3, U > const &right) noexcept
Cross product between quaternion and vector.
Definition quaternion.inl:293
mal_math::vec
Definition of the mathematical vector with fixed size L and type T
Definition vecn.hpp:22
mal_math::vec::operator[]
constexpr T & operator[](size_t i)
Overloaded subscript operator for non-const rvec.
Definition vecn.inl:133
mal_math::vec::operator%=
constexpr vec< L, T > & operator%=(U const value) noexcept
Definition vecn.inl:73
mal_math::vec::get_parameter_pack_size
static constexpr size_t get_parameter_pack_size()
Determines the size of a parameter pack for primitive types.
Definition vecn.inl:146
mal_math::vec::operator*=
constexpr vec< L, T > & operator*=(U const value) noexcept
Definition vecn.inl:53
mal_math::vec::unpack_data
constexpr void unpack_data(size_t offset, U u)
Unpacks a single primitive value into the vector data.
Definition vecn.hpp:134
mal_math::vec::operator/=
constexpr vec< L, T > & operator/=(U const value) noexcept
Definition vecn.inl:63
mal_math::vec::vec
constexpr vec()=default
Default constructor.
mal_math::vec::operator+=
constexpr vec< L, T > & operator+=(U const value) noexcept
Definition vecn.inl:33
mal_math::vec::operator-=
constexpr vec< L, T > & operator-=(U const value) noexcept
Definition vecn.inl:43
mal_math::vec::reset
constexpr void reset() noexcept
Resets the vector to the zero vector.
Definition vecn.inl:23
vec3.hpp
Header file for the 3D vector definition.