From 8644e03586ac9c39741f62cbcbce87b18805538c Mon Sep 17 00:00:00 2001 From: chai Date: Thu, 14 Mar 2019 23:12:54 +0800 Subject: =?UTF-8?q?*=E5=A4=A7=E5=B0=8F=E5=86=99?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Source/Asura.Engine/math/curve.cpp | 0 Source/Asura.Engine/math/curve.h | 0 Source/Asura.Engine/math/functions.cpp | 0 Source/Asura.Engine/math/functions.h | 0 Source/Asura.Engine/math/matrix44.cpp | 0 Source/Asura.Engine/math/matrix44.h | 24 +++ Source/Asura.Engine/math/ranged_value.cpp | 0 Source/Asura.Engine/math/ranged_value.h | 0 Source/Asura.Engine/math/rect.hpp | 32 ++++ Source/Asura.Engine/math/rect.inl | 19 +++ Source/Asura.Engine/math/transform.cpp | 0 Source/Asura.Engine/math/transform.h | 30 ++++ Source/Asura.Engine/math/vector2.hpp | 70 +++++++++ Source/Asura.Engine/math/vector2.inl | 114 +++++++++++++++ Source/Asura.Engine/math/vector3.hpp | 233 +++++++++++++++++++++++++++++ Source/Asura.Engine/math/vector3.inl | 145 ++++++++++++++++++ Source/Asura.Engine/math/vector4.h | 234 ++++++++++++++++++++++++++++++ Source/Asura.Engine/math/vector4.inl | 152 +++++++++++++++++++ 18 files changed, 1053 insertions(+) create mode 100644 Source/Asura.Engine/math/curve.cpp create mode 100644 Source/Asura.Engine/math/curve.h create mode 100644 Source/Asura.Engine/math/functions.cpp create mode 100644 Source/Asura.Engine/math/functions.h create mode 100644 Source/Asura.Engine/math/matrix44.cpp create mode 100644 Source/Asura.Engine/math/matrix44.h create mode 100644 Source/Asura.Engine/math/ranged_value.cpp create mode 100644 Source/Asura.Engine/math/ranged_value.h create mode 100644 Source/Asura.Engine/math/rect.hpp create mode 100644 Source/Asura.Engine/math/rect.inl create mode 100644 Source/Asura.Engine/math/transform.cpp create mode 100644 Source/Asura.Engine/math/transform.h create mode 100644 Source/Asura.Engine/math/vector2.hpp create mode 100644 Source/Asura.Engine/math/vector2.inl create mode 100644 Source/Asura.Engine/math/vector3.hpp create mode 100644 Source/Asura.Engine/math/vector3.inl create mode 100644 Source/Asura.Engine/math/vector4.h create mode 100644 Source/Asura.Engine/math/vector4.inl (limited to 'Source/Asura.Engine/math') diff --git a/Source/Asura.Engine/math/curve.cpp b/Source/Asura.Engine/math/curve.cpp new file mode 100644 index 0000000..e69de29 diff --git a/Source/Asura.Engine/math/curve.h b/Source/Asura.Engine/math/curve.h new file mode 100644 index 0000000..e69de29 diff --git a/Source/Asura.Engine/math/functions.cpp b/Source/Asura.Engine/math/functions.cpp new file mode 100644 index 0000000..e69de29 diff --git a/Source/Asura.Engine/math/functions.h b/Source/Asura.Engine/math/functions.h new file mode 100644 index 0000000..e69de29 diff --git a/Source/Asura.Engine/math/matrix44.cpp b/Source/Asura.Engine/math/matrix44.cpp new file mode 100644 index 0000000..e69de29 diff --git a/Source/Asura.Engine/math/matrix44.h b/Source/Asura.Engine/math/matrix44.h new file mode 100644 index 0000000..4ab3c0b --- /dev/null +++ b/Source/Asura.Engine/math/matrix44.h @@ -0,0 +1,24 @@ +#ifndef __ASURA_ENGINE_MATRIX44_H__ +#define __ASURA_ENGINE_MATRIX44_H__ + +namespace AsuraEngine +{ + namespace Math + { + + /// + /// 4x4¾ØÕó + /// + class Matrix44 + { + public: + + private: + + + }; + + } +} + +#endif \ No newline at end of file diff --git a/Source/Asura.Engine/math/ranged_value.cpp b/Source/Asura.Engine/math/ranged_value.cpp new file mode 100644 index 0000000..e69de29 diff --git a/Source/Asura.Engine/math/ranged_value.h b/Source/Asura.Engine/math/ranged_value.h new file mode 100644 index 0000000..e69de29 diff --git a/Source/Asura.Engine/math/rect.hpp b/Source/Asura.Engine/math/rect.hpp new file mode 100644 index 0000000..f635007 --- /dev/null +++ b/Source/Asura.Engine/math/rect.hpp @@ -0,0 +1,32 @@ +#ifndef __ASURA_ENGINE_RECT_H__ +#define __ASURA_ENGINE_RECT_H__ + +namespace AsuraEngine +{ + namespace Math + { + + template + struct Rect + { + public: + Rect(); + ~Rect(T x, T y, T w, T h); + + template + explicit Rect(const Rect& rect); + + T x, y, w, h; + }; + +#include "Rect.inl" + + // Define the most common types + typedef Rect Recti; + typedef Rect Rectu; + typedef Rect Rectf; + + } +} + +#endif \ No newline at end of file diff --git a/Source/Asura.Engine/math/rect.inl b/Source/Asura.Engine/math/rect.inl new file mode 100644 index 0000000..891a3f8 --- /dev/null +++ b/Source/Asura.Engine/math/rect.inl @@ -0,0 +1,19 @@ +template +inline Rect::Rect() + : x(0) + , y(0) + , w(0) + , h(0) +{ + +} + +template +inline Rect::Rect(T X, T Y, T W, T H) + : x(X) + , y(Y) + , w(W) + , h(H) +{ + +} diff --git a/Source/Asura.Engine/math/transform.cpp b/Source/Asura.Engine/math/transform.cpp new file mode 100644 index 0000000..e69de29 diff --git a/Source/Asura.Engine/math/transform.h b/Source/Asura.Engine/math/transform.h new file mode 100644 index 0000000..33c3d4b --- /dev/null +++ b/Source/Asura.Engine/math/transform.h @@ -0,0 +1,30 @@ +#ifndef __ASURA_ENGINE_TRANSFORM_H__ +#define __ASURA_ENGINE_TRANSFORM_H__ + +#include "Scripting/Portable.h" + +namespace AsuraEngine +{ + namespace Math + { + + class Transform + { + public: + + void Set(float x, float y, float sx, float sy, float ox, float oy, float r); + + void LoadIdentity(); + + void Move(float dx = 0, float dy = 0); + void Rotate(float r); + void Scale(float sx, float sy); + + float m[16]; //4x4 matrix + + }; + + } +} + +#endif \ No newline at end of file diff --git a/Source/Asura.Engine/math/vector2.hpp b/Source/Asura.Engine/math/vector2.hpp new file mode 100644 index 0000000..df78255 --- /dev/null +++ b/Source/Asura.Engine/math/vector2.hpp @@ -0,0 +1,70 @@ +#ifndef __ASURA_ENGINE_VECTOR2_H__ +#define __ASURA_ENGINE_VECTOR2_H__ + +namespace AsuraEngine +{ + namespace Math + { + template + class Vector2 + { + public: + Vector2(); + Vector2(T X, T Y); + + template + explicit Vector2(const Vector2& vector); + + Set(T X, T Y); + + T x; ///< X coordinate of the vector + T y; ///< Y coordinate of the vector + }; + + template + Vector2 operator -(const Vector2& right); + + template + Vector2& operator +=(Vector2& left, const Vector2& right); + + template + Vector2& operator -=(Vector2& left, const Vector2& right); + + template + Vector2 operator +(const Vector2& left, const Vector2& right); + + template + Vector2 operator -(const Vector2& left, const Vector2& right); + + template + Vector2 operator *(const Vector2& left, T right); + + template + Vector2 operator *(T left, const Vector2& right); + + template + Vector2& operator *=(Vector2& left, T right); + + template + Vector2 operator /(const Vector2& left, T right); + + template + Vector2& operator /=(Vector2& left, T right); + + template + bool operator ==(const Vector2& left, const Vector2& right); + + template + bool operator !=(const Vector2& left, const Vector2& right); + +#include "Vector2.inl" + + // Define the most common types + typedef Vector2 Vector2i; + typedef Vector2 Vector2u; + typedef Vector2 Vector2f; + + } +} + +#endif \ No newline at end of file diff --git a/Source/Asura.Engine/math/vector2.inl b/Source/Asura.Engine/math/vector2.inl new file mode 100644 index 0000000..9e131a7 --- /dev/null +++ b/Source/Asura.Engine/math/vector2.inl @@ -0,0 +1,114 @@ +template +inline Vector2::Vector2() : + x(0), + y(0) +{ + +} + +template +inline Vector2::Vector2(T X, T Y) : + x(X), + y(Y) +{ + +} + +template +template +inline Vector2::Vector2(const Vector2& vector) : + x(static_cast(vector.x)), + y(static_cast(vector.y)) +{ +} + +template +inline Vector2::Set(T X, T Y) +{ + x = X; + y = Y; +} + +template +inline Vector2 operator -(const Vector2& right) +{ + return Vector2(-right.x, -right.y); +} + +template +inline Vector2& operator +=(Vector2& left, const Vector2& right) +{ + left.x += right.x; + left.y += right.y; + + return left; +} + +template +inline Vector2& operator -=(Vector2& left, const Vector2& right) +{ + left.x -= right.x; + left.y -= right.y; + + return left; +} + +template +inline Vector2 operator +(const Vector2& left, const Vector2& right) +{ + return Vector2(left.x + right.x, left.y + right.y); +} + +template +inline Vector2 operator -(const Vector2& left, const Vector2& right) +{ + return Vector2(left.x - right.x, left.y - right.y); +} + +template +inline Vector2 operator *(const Vector2& left, T right) +{ + return Vector2(left.x * right, left.y * right); +} + +template +inline Vector2 operator *(T left, const Vector2& right) +{ + return Vector2(right.x * left, right.y * left); +} + +template +inline Vector2& operator *=(Vector2& left, T right) +{ + left.x *= right; + left.y *= right; + + return left; +} + +template +inline Vector2 operator /(const Vector2& left, T right) +{ + return Vector2(left.x / right, left.y / right); +} + +template +inline Vector2& operator /=(Vector2& left, T right) +{ + left.x /= right; + left.y /= right; + + return left; +} + +template +inline bool operator ==(const Vector2& left, const Vector2& right) +{ + return (left.x == right.x) && (left.y == right.y); +} + +template +inline bool operator !=(const Vector2& left, const Vector2& right) +{ + return (left.x != right.x) || (left.y != right.y); +} diff --git a/Source/Asura.Engine/math/vector3.hpp b/Source/Asura.Engine/math/vector3.hpp new file mode 100644 index 0000000..2b23406 --- /dev/null +++ b/Source/Asura.Engine/math/vector3.hpp @@ -0,0 +1,233 @@ +#ifndef __ASURA_ENGINE_VECTOR3_H__ +#define __ASURA_ENGINE_VECTOR3_H__ + +namespace AsuraEngine +{ + namespace Math + { + template + class Vector3 + { + public: + + //////////////////////////////////////////////////////////// + /// \brief Default constructor + /// + /// Creates a Vector3(0, 0, 0). + /// + //////////////////////////////////////////////////////////// + Vector3(); + + //////////////////////////////////////////////////////////// + /// \brief Construct the vector from its coordinates + /// + /// \param X X coordinate + /// \param Y Y coordinate + /// \param Z Z coordinate + /// + //////////////////////////////////////////////////////////// + Vector3(T X, T Y, T Z); + + //////////////////////////////////////////////////////////// + /// \brief Construct the vector from another type of vector + /// + /// This constructor doesn't replace the copy constructor, + /// it's called only when U != T. + /// A call to this constructor will fail to compile if U + /// is not convertible to T. + /// + /// \param vector Vector to convert + /// + //////////////////////////////////////////////////////////// + template + explicit Vector3(const Vector3& vector); + + //////////////////////////////////////////////////////////// + // Member data + //////////////////////////////////////////////////////////// + T x; ///< X coordinate of the vector + T y; ///< Y coordinate of the vector + T z; ///< Z coordinate of the vector + }; + + //////////////////////////////////////////////////////////// + /// \relates Vector3 + /// \brief Overload of unary operator - + /// + /// \param left Vector to negate + /// + /// \return Memberwise opposite of the vector + /// + //////////////////////////////////////////////////////////// + template + Vector3 operator -(const Vector3& left); + + //////////////////////////////////////////////////////////// + /// \relates Vector3 + /// \brief Overload of binary operator += + /// + /// This operator performs a memberwise addition of both vectors, + /// and assigns the result to \a left. + /// + /// \param left Left operand (a vector) + /// \param right Right operand (a vector) + /// + /// \return Reference to \a left + /// + //////////////////////////////////////////////////////////// + template + Vector3& operator +=(Vector3& left, const Vector3& right); + + //////////////////////////////////////////////////////////// + /// \relates Vector3 + /// \brief Overload of binary operator -= + /// + /// This operator performs a memberwise subtraction of both vectors, + /// and assigns the result to \a left. + /// + /// \param left Left operand (a vector) + /// \param right Right operand (a vector) + /// + /// \return Reference to \a left + /// + //////////////////////////////////////////////////////////// + template + Vector3& operator -=(Vector3& left, const Vector3& right); + + //////////////////////////////////////////////////////////// + /// \relates Vector3 + /// \brief Overload of binary operator + + /// + /// \param left Left operand (a vector) + /// \param right Right operand (a vector) + /// + /// \return Memberwise addition of both vectors + /// + //////////////////////////////////////////////////////////// + template + Vector3 operator +(const Vector3& left, const Vector3& right); + + //////////////////////////////////////////////////////////// + /// \relates Vector3 + /// \brief Overload of binary operator - + /// + /// \param left Left operand (a vector) + /// \param right Right operand (a vector) + /// + /// \return Memberwise subtraction of both vectors + /// + //////////////////////////////////////////////////////////// + template + Vector3 operator -(const Vector3& left, const Vector3& right); + + //////////////////////////////////////////////////////////// + /// \relates Vector3 + /// \brief Overload of binary operator * + /// + /// \param left Left operand (a vector) + /// \param right Right operand (a scalar value) + /// + /// \return Memberwise multiplication by \a right + /// + //////////////////////////////////////////////////////////// + template + Vector3 operator *(const Vector3& left, T right); + + //////////////////////////////////////////////////////////// + /// \relates Vector3 + /// \brief Overload of binary operator * + /// + /// \param left Left operand (a scalar value) + /// \param right Right operand (a vector) + /// + /// \return Memberwise multiplication by \a left + /// + //////////////////////////////////////////////////////////// + template + Vector3 operator *(T left, const Vector3& right); + + //////////////////////////////////////////////////////////// + /// \relates Vector3 + /// \brief Overload of binary operator *= + /// + /// This operator performs a memberwise multiplication by \a right, + /// and assigns the result to \a left. + /// + /// \param left Left operand (a vector) + /// \param right Right operand (a scalar value) + /// + /// \return Reference to \a left + /// + //////////////////////////////////////////////////////////// + template + Vector3& operator *=(Vector3& left, T right); + + //////////////////////////////////////////////////////////// + /// \relates Vector3 + /// \brief Overload of binary operator / + /// + /// \param left Left operand (a vector) + /// \param right Right operand (a scalar value) + /// + /// \return Memberwise division by \a right + /// + //////////////////////////////////////////////////////////// + template + Vector3 operator /(const Vector3& left, T right); + + //////////////////////////////////////////////////////////// + /// \relates Vector3 + /// \brief Overload of binary operator /= + /// + /// This operator performs a memberwise division by \a right, + /// and assigns the result to \a left. + /// + /// \param left Left operand (a vector) + /// \param right Right operand (a scalar value) + /// + /// \return Reference to \a left + /// + //////////////////////////////////////////////////////////// + template + Vector3& operator /=(Vector3& left, T right); + + //////////////////////////////////////////////////////////// + /// \relates Vector3 + /// \brief Overload of binary operator == + /// + /// This operator compares strict equality between two vectors. + /// + /// \param left Left operand (a vector) + /// \param right Right operand (a vector) + /// + /// \return True if \a left is equal to \a right + /// + //////////////////////////////////////////////////////////// + template + bool operator ==(const Vector3& left, const Vector3& right); + + //////////////////////////////////////////////////////////// + /// \relates Vector3 + /// \brief Overload of binary operator != + /// + /// This operator compares strict difference between two vectors. + /// + /// \param left Left operand (a vector) + /// \param right Right operand (a vector) + /// + /// \return True if \a left is not equal to \a right + /// + //////////////////////////////////////////////////////////// + template + bool operator !=(const Vector3& left, const Vector3& right); + +#include "Vector3.inl" + + // Define the most common types + typedef Vector3 Vector3i; + typedef Vector3 Vector3f; + + } +} + +#endif \ No newline at end of file diff --git a/Source/Asura.Engine/math/vector3.inl b/Source/Asura.Engine/math/vector3.inl new file mode 100644 index 0000000..3a2aa93 --- /dev/null +++ b/Source/Asura.Engine/math/vector3.inl @@ -0,0 +1,145 @@ + + +//////////////////////////////////////////////////////////// +template +inline Vector3::Vector3() : + x(0), + y(0), + z(0) +{ + +} + + +//////////////////////////////////////////////////////////// +template +inline Vector3::Vector3(T X, T Y, T Z) : + x(X), + y(Y), + z(Z) +{ + +} + + +//////////////////////////////////////////////////////////// +template +template +inline Vector3::Vector3(const Vector3& vector) : + x(static_cast(vector.x)), + y(static_cast(vector.y)), + z(static_cast(vector.z)) +{ +} + + +//////////////////////////////////////////////////////////// +template +inline Vector3 operator -(const Vector3& left) +{ + return Vector3(-left.x, -left.y, -left.z); +} + + +//////////////////////////////////////////////////////////// +template +inline Vector3& operator +=(Vector3& left, const Vector3& right) +{ + left.x += right.x; + left.y += right.y; + left.z += right.z; + + return left; +} + + +//////////////////////////////////////////////////////////// +template +inline Vector3& operator -=(Vector3& left, const Vector3& right) +{ + left.x -= right.x; + left.y -= right.y; + left.z -= right.z; + + return left; +} + + +//////////////////////////////////////////////////////////// +template +inline Vector3 operator +(const Vector3& left, const Vector3& right) +{ + return Vector3(left.x + right.x, left.y + right.y, left.z + right.z); +} + + +//////////////////////////////////////////////////////////// +template +inline Vector3 operator -(const Vector3& left, const Vector3& right) +{ + return Vector3(left.x - right.x, left.y - right.y, left.z - right.z); +} + + +//////////////////////////////////////////////////////////// +template +inline Vector3 operator *(const Vector3& left, T right) +{ + return Vector3(left.x * right, left.y * right, left.z * right); +} + + +//////////////////////////////////////////////////////////// +template +inline Vector3 operator *(T left, const Vector3& right) +{ + return Vector3(right.x * left, right.y * left, right.z * left); +} + + +//////////////////////////////////////////////////////////// +template +inline Vector3& operator *=(Vector3& left, T right) +{ + left.x *= right; + left.y *= right; + left.z *= right; + + return left; +} + + +//////////////////////////////////////////////////////////// +template +inline Vector3 operator /(const Vector3& left, T right) +{ + return Vector3(left.x / right, left.y / right, left.z / right); +} + + +//////////////////////////////////////////////////////////// +template +inline Vector3& operator /=(Vector3& left, T right) +{ + left.x /= right; + left.y /= right; + left.z /= right; + + return left; +} + + +//////////////////////////////////////////////////////////// +template +inline bool operator ==(const Vector3& left, const Vector3& right) +{ + return (left.x == right.x) && (left.y == right.y) && (left.z == right.z); +} + + +//////////////////////////////////////////////////////////// +template +inline bool operator !=(const Vector3& left, const Vector3& right) +{ + return (left.x != right.x) || (left.y != right.y) || (left.z != right.z); +} diff --git a/Source/Asura.Engine/math/vector4.h b/Source/Asura.Engine/math/vector4.h new file mode 100644 index 0000000..13a9d8a --- /dev/null +++ b/Source/Asura.Engine/math/vector4.h @@ -0,0 +1,234 @@ +#ifndef __ASURA_ENGINE_VECTOR4_H__ +#define __ASURA_ENGINE_VECTOR4_H__ + +namespace AsuraEngine +{ + namespace Math + { + template + class Vector4 + { + public: + + //////////////////////////////////////////////////////////// + /// \brief Default constructor + /// + /// Creates a Vector4(0, 0, 0). + /// + //////////////////////////////////////////////////////////// + Vector4(); + + //////////////////////////////////////////////////////////// + /// \brief Construct the vector from its coordinates + /// + /// \param X X coordinate + /// \param Y Y coordinate + /// \param Z Z coordinate + /// + //////////////////////////////////////////////////////////// + Vector4(T X, T Y, T Z, T W); + + //////////////////////////////////////////////////////////// + /// \brief Construct the vector from another type of vector + /// + /// This constructor doesn't replace the copy constructor, + /// it's called only when U != T. + /// A call to this constructor will fail to compile if U + /// is not convertible to T. + /// + /// \param vector Vector to convert + /// + //////////////////////////////////////////////////////////// + template + explicit Vector4(const Vector4& vector); + + //////////////////////////////////////////////////////////// + // Member data + //////////////////////////////////////////////////////////// + T x; ///< X coordinate of the vector + T y; ///< Y coordinate of the vector + T z; ///< Z coordinate of the vector + T w; ///< W coordinate of the vector + }; + + //////////////////////////////////////////////////////////// + /// \relates Vector4 + /// \brief Overload of unary operator - + /// + /// \param left Vector to negate + /// + /// \return Memberwise opposite of the vector + /// + //////////////////////////////////////////////////////////// + template + Vector4 operator -(const Vector4& left); + + //////////////////////////////////////////////////////////// + /// \relates Vector4 + /// \brief Overload of binary operator += + /// + /// This operator performs a memberwise addition of both vectors, + /// and assigns the result to \a left. + /// + /// \param left Left operand (a vector) + /// \param right Right operand (a vector) + /// + /// \return Reference to \a left + /// + //////////////////////////////////////////////////////////// + template + Vector4& operator +=(Vector4& left, const Vector4& right); + + //////////////////////////////////////////////////////////// + /// \relates Vector4 + /// \brief Overload of binary operator -= + /// + /// This operator performs a memberwise subtraction of both vectors, + /// and assigns the result to \a left. + /// + /// \param left Left operand (a vector) + /// \param right Right operand (a vector) + /// + /// \return Reference to \a left + /// + //////////////////////////////////////////////////////////// + template + Vector4& operator -=(Vector4& left, const Vector4& right); + + //////////////////////////////////////////////////////////// + /// \relates Vector4 + /// \brief Overload of binary operator + + /// + /// \param left Left operand (a vector) + /// \param right Right operand (a vector) + /// + /// \return Memberwise addition of both vectors + /// + //////////////////////////////////////////////////////////// + template + Vector4 operator +(const Vector4& left, const Vector4& right); + + //////////////////////////////////////////////////////////// + /// \relates Vector4 + /// \brief Overload of binary operator - + /// + /// \param left Left operand (a vector) + /// \param right Right operand (a vector) + /// + /// \return Memberwise subtraction of both vectors + /// + //////////////////////////////////////////////////////////// + template + Vector4 operator -(const Vector4& left, const Vector4& right); + + //////////////////////////////////////////////////////////// + /// \relates Vector4 + /// \brief Overload of binary operator * + /// + /// \param left Left operand (a vector) + /// \param right Right operand (a scalar value) + /// + /// \return Memberwise multiplication by \a right + /// + //////////////////////////////////////////////////////////// + template + Vector4 operator *(const Vector4& left, T right); + + //////////////////////////////////////////////////////////// + /// \relates Vector4 + /// \brief Overload of binary operator * + /// + /// \param left Left operand (a scalar value) + /// \param right Right operand (a vector) + /// + /// \return Memberwise multiplication by \a left + /// + //////////////////////////////////////////////////////////// + template + Vector4 operator *(T left, const Vector4& right); + + //////////////////////////////////////////////////////////// + /// \relates Vector4 + /// \brief Overload of binary operator *= + /// + /// This operator performs a memberwise multiplication by \a right, + /// and assigns the result to \a left. + /// + /// \param left Left operand (a vector) + /// \param right Right operand (a scalar value) + /// + /// \return Reference to \a left + /// + //////////////////////////////////////////////////////////// + template + Vector4& operator *=(Vector4& left, T right); + + //////////////////////////////////////////////////////////// + /// \relates Vector4 + /// \brief Overload of binary operator / + /// + /// \param left Left operand (a vector) + /// \param right Right operand (a scalar value) + /// + /// \return Memberwise division by \a right + /// + //////////////////////////////////////////////////////////// + template + Vector4 operator /(const Vector4& left, T right); + + //////////////////////////////////////////////////////////// + /// \relates Vector4 + /// \brief Overload of binary operator /= + /// + /// This operator performs a memberwise division by \a right, + /// and assigns the result to \a left. + /// + /// \param left Left operand (a vector) + /// \param right Right operand (a scalar value) + /// + /// \return Reference to \a left + /// + //////////////////////////////////////////////////////////// + template + Vector4& operator /=(Vector4& left, T right); + + //////////////////////////////////////////////////////////// + /// \relates Vector4 + /// \brief Overload of binary operator == + /// + /// This operator compares strict equality between two vectors. + /// + /// \param left Left operand (a vector) + /// \param right Right operand (a vector) + /// + /// \return True if \a left is equal to \a right + /// + //////////////////////////////////////////////////////////// + template + bool operator ==(const Vector4& left, const Vector4& right); + + //////////////////////////////////////////////////////////// + /// \relates Vector4 + /// \brief Overload of binary operator != + /// + /// This operator compares strict difference between two vectors. + /// + /// \param left Left operand (a vector) + /// \param right Right operand (a vector) + /// + /// \return True if \a left is not equal to \a right + /// + //////////////////////////////////////////////////////////// + template + bool operator !=(const Vector4& left, const Vector4& right); + +#include "Vector4.inl" + + // Define the most common types + typedef Vector4 Vector4i; + typedef Vector4 Vector4f; + + } +} + +#endif \ No newline at end of file diff --git a/Source/Asura.Engine/math/vector4.inl b/Source/Asura.Engine/math/vector4.inl new file mode 100644 index 0000000..025bfcc --- /dev/null +++ b/Source/Asura.Engine/math/vector4.inl @@ -0,0 +1,152 @@ + + +//////////////////////////////////////////////////////////// +template +inline Vector4::Vector4() : + x(0), + y(0), + z(0), + w(0) +{ + +} + + +//////////////////////////////////////////////////////////// +template +inline Vector4::Vector4(T X, T Y, T Z) : + x(X), + y(Y), + z(Z), + w(0) +{ + +} + + +//////////////////////////////////////////////////////////// +template +template +inline Vector4::Vector4(const Vector4& vector) : + x(static_cast(vector.x)), + y(static_cast(vector.y)), + z(static_cast(vector.z)) + w(static_cast(vector.w)) +{ +} + + +//////////////////////////////////////////////////////////// +template +inline Vector4 operator -(const Vector4& left) +{ + return Vector4(-left.x, -left.y, -left.z, -left.w); +} + + +//////////////////////////////////////////////////////////// +template +inline Vector4& operator +=(Vector4& left, const Vector4& right) +{ + left.x += right.x; + left.y += right.y; + left.z += right.z; + left.w += right.w; + + return left; +} + + +//////////////////////////////////////////////////////////// +template +inline Vector4& operator -=(Vector4& left, const Vector4& right) +{ + left.x -= right.x; + left.y -= right.y; + left.z -= right.z; + left.w -= right.w; + + return left; +} + + +//////////////////////////////////////////////////////////// +template +inline Vector4 operator +(const Vector4& left, const Vector4& right) +{ + return Vector4(left.x + right.x, left.y + right.y, left.z + right.z, left.w + right.w); +} + + +//////////////////////////////////////////////////////////// +template +inline Vector4 operator -(const Vector4& left, const Vector4& right) +{ + return Vector4(left.x - right.x, left.y - right.y, left.z - right.z, left.w - right.w); +} + + +//////////////////////////////////////////////////////////// +template +inline Vector4 operator *(const Vector4& left, T right) +{ + return Vector4(left.x * right, left.y * right, left.z * right, left.w * right); +} + + +//////////////////////////////////////////////////////////// +template +inline Vector4 operator *(T left, const Vector4& right) +{ + return Vector4(right.x * left, right.y * left, right.z * left, right.w * left); +} + + +//////////////////////////////////////////////////////////// +template +inline Vector4& operator *=(Vector4& left, T right) +{ + left.x *= right; + left.y *= right; + left.z *= right; + left.w *= right; + + return left; +} + + +//////////////////////////////////////////////////////////// +template +inline Vector4 operator /(const Vector4& left, T right) +{ + return Vector4(left.x / right, left.y / right, left.z / right, left.w / right); +} + + +//////////////////////////////////////////////////////////// +template +inline Vector4& operator /=(Vector4& left, T right) +{ + left.x /= right; + left.y /= right; + left.z /= right; + left.w /= right; + + return left; +} + + +//////////////////////////////////////////////////////////// +template +inline bool operator ==(const Vector4& left, const Vector4& right) +{ + return (left.x == right.x) && (left.y == right.y) && (left.z == right.z) && (left.w == right.w); +} + + +//////////////////////////////////////////////////////////// +template +inline bool operator !=(const Vector4& left, const Vector4& right) +{ + return (left.x != right.x) || (left.y != right.y) || (left.z != right.z) || (left.w != right.w); +} -- cgit v1.1-26-g67d0