admin/omath
1
0
Fork 0
mirror of https://github.com/orange-cpp/omath.git synced 2026-02-13 07:03:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

improved naming

Browse Source
This commit is contained in:
Orange
2025-05-13 09:47:08 +03:00
parent 52024285d2
commit 17eb0cd0dc
3 changed files with 115 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

72
include/omath/vector2.hpp
View File

@@ -30,78 +30,78 @@ namespace omath
// Equality operators // Equality operators
[[nodiscard]] [[nodiscard]]
constexpr bool operator==(const Vector2& src) const noexcept constexpr bool operator==(const Vector2& other) const noexcept
{ {
return x == src.x && y == src.y; return x == other.x && y == other.y;
} }
[[nodiscard]] [[nodiscard]]
constexpr bool operator!=(const Vector2& src) const noexcept constexpr bool operator!=(const Vector2& other) const noexcept
{ {
return !(*this == src); return !(*this == other);
} }
// Compound assignment operators // Compound assignment operators
constexpr Vector2& operator+=(const Vector2& v) noexcept constexpr Vector2& operator+=(const Vector2& other) noexcept
{ {
x += v.x; x += other.x;
y += v.y; y += other.y;
return *this; return *this;
} }
constexpr Vector2& operator-=(const Vector2& v) noexcept constexpr Vector2& operator-=(const Vector2& other) noexcept
{ {
x -= v.x; x -= other.x;
y -= v.y; y -= other.y;
return *this; return *this;
} }
constexpr Vector2& operator*=(const Vector2& v) noexcept constexpr Vector2& operator*=(const Vector2& other) noexcept
{ {
x *= v.x; x *= other.x;
y *= v.y; y *= other.y;
return *this; return *this;
} }
constexpr Vector2& operator/=(const Vector2& v) noexcept constexpr Vector2& operator/=(const Vector2& other) noexcept
{ {
x /= v.x; x /= other.x;
y /= v.y; y /= other.y;
return *this; return *this;
} }
constexpr Vector2& operator*=(const Type& fl) noexcept constexpr Vector2& operator*=(const Type& value) noexcept
{ {
x *= fl; x *= value;
y *= fl; y *= value;
return *this; return *this;
} }
constexpr Vector2& operator/=(const Type& fl) noexcept constexpr Vector2& operator/=(const Type& value) noexcept
{ {
x /= fl; x /= value;
y /= fl; y /= value;
return *this; return *this;
} }
constexpr Vector2& operator+=(const Type& fl) noexcept constexpr Vector2& operator+=(const Type& value) noexcept
{ {
x += fl; x += value;
y += fl; y += value;
return *this; return *this;
} }
constexpr Vector2& operator-=(const Type& fl) noexcept constexpr Vector2& operator-=(const Type& value) noexcept
{ {
x -= fl; x -= value;
y -= fl; y -= value;
return *this; return *this;
} }
@@ -164,24 +164,24 @@ namespace omath
} }
// Binary arithmetic operators // Binary arithmetic operators
[[nodiscard]] constexpr Vector2 operator+(const Vector2& v) const noexcept [[nodiscard]] constexpr Vector2 operator+(const Vector2& other) const noexcept
{ {
return {x + v.x, y + v.y}; return {x + other.x, y + other.y};
} }
[[nodiscard]] constexpr Vector2 operator-(const Vector2& v) const noexcept [[nodiscard]] constexpr Vector2 operator-(const Vector2& other) const noexcept
{ {
return {x - v.x, y - v.y}; return {x - other.x, y - other.y};
} }
[[nodiscard]] constexpr Vector2 operator*(const Type& fl) const noexcept [[nodiscard]] constexpr Vector2 operator*(const Type& value) const noexcept
{ {
return {x * fl, y * fl}; return {x * value, y * value};
} }
[[nodiscard]] constexpr Vector2 operator/(const Type& fl) const noexcept [[nodiscard]] constexpr Vector2 operator/(const Type& value) const noexcept
{ {
return {x / fl, y / fl}; return {x / value, y / value};
} }
// Sum of elements // Sum of elements

86
include/omath/vector3.hpp
View File

@@ -29,76 +29,76 @@ namespace omath
} }
constexpr Vector3() noexcept: Vector2<Type>() {}; constexpr Vector3() noexcept: Vector2<Type>() {};
[[nodiscard]] constexpr bool operator==(const Vector3& src) const noexcept [[nodiscard]] constexpr bool operator==(const Vector3& other) const noexcept
{ {
return Vector2<Type>::operator==(src) && (src.z == z); return Vector2<Type>::operator==(other) && (other.z == z);
} }
[[nodiscard]] constexpr bool operator!=(const Vector3& src) const noexcept [[nodiscard]] constexpr bool operator!=(const Vector3& other) const noexcept
{ {
return !(*this == src); return !(*this == other);
} }
constexpr Vector3& operator+=(const Vector3& v) noexcept constexpr Vector3& operator+=(const Vector3& other) noexcept
{ {
Vector2<Type>::operator+=(v); Vector2<Type>::operator+=(other);
z += v.z; z += other.z;
return *this; return *this;
} }
constexpr Vector3& operator-=(const Vector3& v) noexcept constexpr Vector3& operator-=(const Vector3& other) noexcept
{ {
Vector2<Type>::operator-=(v); Vector2<Type>::operator-=(other);
z -= v.z; z -= other.z;
return *this; return *this;
} }
constexpr Vector3& operator*=(const float fl) noexcept constexpr Vector3& operator*=(const Type& value) noexcept
{ {
Vector2<Type>::operator*=(fl); Vector2<Type>::operator*=(value);
z *= fl; z *= value;
return *this; return *this;
} }
constexpr Vector3& operator*=(const Vector3& v) noexcept constexpr Vector3& operator*=(const Vector3& other) noexcept
{ {
Vector2<Type>::operator*=(v); Vector2<Type>::operator*=(other);
z *= v.z; z *= other.z;
return *this; return *this;
} }
constexpr Vector3& operator/=(const Vector3& v) noexcept constexpr Vector3& operator/=(const Vector3& other) noexcept
{ {
Vector2<Type>::operator/=(v); Vector2<Type>::operator/=(other);
z /= v.z; z /= other.z;
return *this; return *this;
} }
constexpr Vector3& operator+=(const float fl) noexcept constexpr Vector3& operator+=(const Type& value) noexcept
{ {
Vector2<Type>::operator+=(fl); Vector2<Type>::operator+=(value);
z += fl; z += value;
return *this; return *this;
} }
constexpr Vector3& operator/=(const float fl) noexcept constexpr Vector3& operator/=(const Type& value) noexcept
{ {
Vector2<Type>::operator/=(fl); Vector2<Type>::operator/=(value);
z /= fl; z /= value;
return *this; return *this;
} }
constexpr Vector3& operator-=(const float fl) noexcept constexpr Vector3& operator-=(const Type& value) noexcept
{ {
Vector2<Type>::operator-=(fl); Vector2<Type>::operator-=(value);
z -= fl; z -= value;
return *this; return *this;
} }
@@ -175,40 +175,42 @@ namespace omath
return {-this->x, -this->y, -z}; return {-this->x, -this->y, -z};
} }
[[nodiscard]] constexpr Vector3 operator+(const Vector3& v) const noexcept [[nodiscard]] constexpr Vector3 operator+(const Vector3& other) const noexcept
{ {
return {this->x + v.x, this->y + v.y, z + v.z}; return {this->x + other.x, this->y + other.y, z + other.z};
} }
[[nodiscard]] constexpr Vector3 operator-(const Vector3& v) const noexcept [[nodiscard]] constexpr Vector3 operator-(const Vector3& other) const noexcept
{ {
return {this->x - v.x, this->y - v.y, z - v.z}; return {this->x - other.x, this->y - other.y, z - other.z};
} }
[[nodiscard]] constexpr Vector3 operator*(const Type& fl) const noexcept [[nodiscard]] constexpr Vector3 operator*(const Type& value) const noexcept
{ {
return {this->x * fl, this->y * fl, z * fl}; return {this->x * value, this->y * value, z * value};
} }
[[nodiscard]] constexpr Vector3 operator*(const Vector3& v) const noexcept [[nodiscard]] constexpr Vector3 operator*(const Vector3& other) const noexcept
{ {
return {this->x * v.x, this->y * v.y, z * v.z}; return {this->x * other.x, this->y * other.y, z * other.z};
} }
[[nodiscard]] constexpr Vector3 operator/(const Type& fl) const noexcept [[nodiscard]] constexpr Vector3 operator/(const Type& value) const noexcept
{ {
return {this->x / fl, this->y / fl, z / fl}; return {this->x / value, this->y / value, z / value};
} }
[[nodiscard]] constexpr Vector3 operator/(const Vector3& v) const noexcept [[nodiscard]] constexpr Vector3 operator/(const Vector3& other) const noexcept
{ {
return {this->x / v.x, this->y / v.y, z / v.z}; return {this->x / other.x, this->y / other.y, z / other.z};
} }
[[nodiscard]] constexpr Vector3 cross(const Vector3& v) const noexcept [[nodiscard]] constexpr Vector3 cross(const Vector3& other) const noexcept
{ {
return {this->y * v.z - z * v.y, z * v.x - this->x * v.z, this->x * v.y - this->y * v.x}; return {this->y * other.z - z * other.y, z * other.x - this->x * other.z,
this->x * other.y - this->y * other.x};
} }
[[nodiscard]] constexpr Type sum() const noexcept [[nodiscard]] constexpr Type sum() const noexcept
{ {
return sum_2d() + z; return sum_2d() + z;

69
include/omath/vector4.hpp
View File

@@ -9,6 +9,7 @@
namespace omath namespace omath
{ {
template<class Type> template<class Type>
requires std::is_arithmetic_v<Type>
class Vector4 : public Vector3<Type> class Vector4 : public Vector3<Type>
{ {
public: public:
@@ -20,61 +21,61 @@ namespace omath
constexpr Vector4() noexcept : Vector3<Type>(), w(0) {}; constexpr Vector4() noexcept : Vector3<Type>(), w(0) {};
[[nodiscard]] [[nodiscard]]
constexpr bool operator==(const Vector4& src) const noexcept constexpr bool operator==(const Vector4& other) const noexcept
{ {
return Vector3<Type>::operator==(src) && w == src.w; return Vector3<Type>::operator==(other) && w == other.w;
} }
[[nodiscard]] [[nodiscard]]
constexpr bool operator!=(const Vector4& src) const noexcept constexpr bool operator!=(const Vector4& other) const noexcept
{ {
return !(*this == src); return !(*this == other);
} }
constexpr Vector4& operator+=(const Vector4& v) noexcept constexpr Vector4& operator+=(const Vector4& other) noexcept
{ {
Vector3<Type>::operator+=(v); Vector3<Type>::operator+=(other);
w += v.w; w += other.w;
return *this; return *this;
} }
constexpr Vector4& operator-=(const Vector4& v) noexcept constexpr Vector4& operator-=(const Vector4& other) noexcept
{ {
Vector3<Type>::operator-=(v); Vector3<Type>::operator-=(other);
w -= v.w; w -= other.w;
return *this; return *this;
} }
constexpr Vector4& operator*=(const Type& scalar) noexcept constexpr Vector4& operator*=(const Type& value) noexcept
{ {
Vector3<Type>::operator*=(scalar); Vector3<Type>::operator*=(value);
w *= scalar; w *= value;
return *this; return *this;
} }
constexpr Vector4& operator*=(const Vector4& v) noexcept constexpr Vector4& operator*=(const Vector4& other) noexcept
{ {
Vector3<Type>::operator*=(v); Vector3<Type>::operator*=(other);
w *= v.w; w *= other.w;
return *this; return *this;
} }
constexpr Vector4& operator/=(const Type& scalar) noexcept constexpr Vector4& operator/=(const Type& value) noexcept
{ {
Vector3<Type>::operator/=(scalar); Vector3<Type>::operator/=(value);
w /= scalar; w /= value;
return *this; return *this;
} }
constexpr Vector4& operator/=(const Vector4& v) noexcept constexpr Vector4& operator/=(const Vector4& other) noexcept
{ {
Vector3<Type>::operator/=(v); Vector3<Type>::operator/=(other);
w /= v.w; w /= other.w;
return *this; return *this;
} }
@@ -116,39 +117,39 @@ namespace omath
} }
[[nodiscard]] [[nodiscard]]
constexpr Vector4 operator+(const Vector4& v) const noexcept constexpr Vector4 operator+(const Vector4& other) const noexcept
{ {
return {this->x + v.x, this->y + v.y, this->z + v.z, w + v.w}; return {this->x + other.x, this->y + other.y, this->z + other.z, w + other.w};
} }
[[nodiscard]] [[nodiscard]]
constexpr Vector4 operator-(const Vector4& v) const noexcept constexpr Vector4 operator-(const Vector4& other) const noexcept
{ {
return {this->x - v.x, this->y - v.y, this->z - v.z, w - v.w}; return {this->x - other.x, this->y - other.y, this->z - other.z, w - other.w};
} }
[[nodiscard]] [[nodiscard]]
constexpr Vector4 operator*(const Type& scalar) const noexcept constexpr Vector4 operator*(const Type& value) const noexcept
{ {
return {this->x * scalar, this->y * scalar, this->z * scalar, w * scalar}; return {this->x * value, this->y * value, this->z * value, w * value};
} }
[[nodiscard]] [[nodiscard]]
constexpr Vector4 operator*(const Vector4& v) const noexcept constexpr Vector4 operator*(const Vector4& other) const noexcept
{ {
return {this->x * v.x, this->y * v.y, this->z * v.z, w * v.w}; return {this->x * other.x, this->y * other.y, this->z * other.z, w * other.w};
} }
[[nodiscard]] [[nodiscard]]
constexpr Vector4 operator/(const Type& scalar) const noexcept constexpr Vector4 operator/(const Type& value) const noexcept
{ {
return {this->x / scalar, this->y / scalar, this->z / scalar, w / scalar}; return {this->x / value, this->y / value, this->z / value, w / value};
} }
[[nodiscard]] [[nodiscard]]
constexpr Vector4 operator/(const Vector4& v) const noexcept constexpr Vector4 operator/(const Vector4& other) const noexcept
{ {
return {this->x / v.x, this->y / v.y, this->z / v.z, w / v.w}; return {this->x / other.x, this->y / other.y, this->z / other.z, w / other.w};
} }
[[nodiscard]] [[nodiscard]]