Update Vector header

Named the X, Y enum: Axes.
Removed unnecessary constructors, left only one.
Removed Clear(), it was a duplicate of Reset(). And this isn't memory pool land.
Rewrote a bunch of methods to be shorter or more readable.
Const all the things.
Removed unnecessary copy-assignment. Default does the same thing.

Author: orengg

System/Vector.cpp

@@ -70,20 +70,10 @@ namespace RTE {
 		return *this;
 	}
 
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-	Vector & Vector::operator=(const Vector &rhs) {
-		if (*this != rhs) {
-			m_X = rhs.m_X;
-			m_Y = rhs.m_Y;
-		}
-		return *this;
-	}
-
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 	Vector & Vector::operator=(const std::deque<Vector> &rhs) {
-		Clear();
+		Reset();
 		if (!rhs.empty()) {
 			for (const Vector &vector : rhs) {
 				*this += vector;

System/Vector.h

@@ -6,7 +6,7 @@
 
 namespace RTE {
 
-	enum { X = 0, Y = 1 };
+	enum Axes { X = 0, Y = 1 };
 
 	/// <summary>
 	/// A useful 2D float vector.
@@ -21,41 +21,22 @@ namespace RTE {
 		float m_Y; //!< Y value of this vector.
 
 #pragma region Creation
-		/// <summary>
-		/// Constructor method used to instantiate a Vector object.
-		/// </summary>
-		Vector() { Clear(); }
-
 		/// <summary>
 		/// Constructor method used to instantiate a Vector object from X and Y values.
 		/// </summary>
 		/// <param name="inputX">Float defining the initial X value of this Vector.</param>
 		/// <param name="inputY">Float defining the initial Y value of this Vector.</param>
-		Vector(float inputX, float inputY) { Create(inputX, inputY); }
-
-		/// <summary>
-		/// Copy constructor method used to instantiate a Vector object identical to an already existing one.
-		/// </summary>
-		/// <param name="reference">A Vector object which is passed in by reference.</param>
-		Vector(const Vector &reference) { Create(reference.m_X, reference.m_Y); }
-
-		/// <summary>
-		/// Makes the Vector object ready for use.
-		/// </summary>
-		/// <param name="inputX">Float defining the initial X value of this Vector.</param>
-		/// <param name="inputY">Float defining the initial Y value of this Vector.</param>
-		/// <returns>An error return value signaling success or any particular failure. Anything below 0 is an error signal.</returns>
-		int Create(float inputX, float inputY) { m_X = inputX; m_Y = inputY; return 0; }
+		Vector(const float inputX = 0.0F, const float inputY = 0.0F) :
+		m_X(inputX),
+		m_Y(inputY) {};
 #pragma endregion
 
-#pragma region Destruction
+#pragma region Getters and Setters
 		/// <summary>
 		/// Sets both the X and Y of this Vector to zero.
 		/// </summary>
-		void Reset() { m_X = m_Y = 0.0F; }
-#pragma endregion
+		void Reset() { m_X = 0.0F; m_Y = 0.0F; }
 
-#pragma region Getters and Setters
 		/// <summary>
 		/// Gets the X value of this Vector.
 		/// </summary>
@@ -110,39 +91,39 @@ namespace RTE {
 		/// Gets the absolute largest of the two elements. Will always be positive.
 		/// </summary>
 		/// <returns>A float describing the largest value of the two, but not the magnitude.</returns>
-		float GetLargest() const { return std::fabs((std::fabs(m_X) > std::fabs(m_Y)) ? m_X : m_Y); }
+		float GetLargest() const { return std::max(std::abs(m_X), std::abs(m_Y)); }
 
 		/// <summary>
 		/// Gets the absolute smallest of the two elements. Will always be positive.
 		/// </summary>
 		/// <returns>A float describing the smallest value of the two, but not the magnitude.</returns>
-		float GetSmallest() const { return std::fabs((std::fabs(m_X) > std::fabs(m_Y)) ? m_Y : m_X); }
+		float GetSmallest() const { return std::min(std::abs(m_X), std::abs(m_Y)); }
 
 		/// <summary>
 		/// Gets a Vector identical to this except that its X component is flipped.
 		/// </summary>
 		/// <param name="xFlip">Whether to flip the X axis of the return vector or not.</param>
 		/// <returns>A copy of this vector with flipped X axis.</returns>
-		Vector GetXFlipped(bool xFlip = true) const { Vector retVec((xFlip ? -m_X : m_X), m_Y); return retVec; }
+		Vector GetXFlipped(const bool xFlip = true) const { return Vector(xFlip ? -m_X : m_X, m_Y); }
 
 		/// <summary>
 		/// Flips the X element of this Vector.
 		/// </summary>
 		/// <param name="flipX">Whether or not to flip the X element or not.</param>
-		void FlipX(bool flipX = true) { m_X = flipX ? -m_X : m_X; }
+		void FlipX(const bool flipX = true) { *this = GetYFlipped(flipX); }
 
 		/// <summary>
 		/// Gets a Vector identical to this except that its Y component is flipped.
 		/// </summary>
 		/// <param name="yFlip">Whether to flip the Y axis of the return vector or not.</param>
 		/// <returns>A copy of this vector with flipped Y axis.</returns>
-		Vector GetYFlipped(bool yFlip = true) const { Vector retVec(m_X, (yFlip ? -m_Y : m_Y)); return retVec; }
+		Vector GetYFlipped(const bool yFlip = true) const { return Vector(m_X, yFlip ? -m_Y : m_Y); }
 
 		/// <summary>
 		/// Flips the Y element of this Vector.
 		/// </summary>
 		/// <param name="flipY">Whether or not to flip the Y element or not.</param>
-		void FlipY(bool flipY = true) { m_Y = flipY ? -m_Y : m_Y; }
+		void FlipY(const bool flipY = true) { *this = GetYFlipped(flipY); }
 
 		/// <summary>
 		/// Indicates whether the X component of this Vector is 0.
@@ -167,7 +148,7 @@ namespace RTE {
 		/// </summary>
 		/// <param name="opp">The Vector to compare with.</param>
 		/// <returns>Whether the X and Y components of this Vector each have opposite signs to their corresponding components of a passed in Vector.</returns>
-		bool IsOpposedTo(const Vector &opp) { return ((XIsZero() && opp.XIsZero()) || (std::signbit(m_X) != std::signbit(opp.m_X))) && ((YIsZero() && opp.YIsZero()) || (std::signbit(m_Y) != std::signbit(opp.m_Y))); }
+		bool IsOpposedTo(const Vector &opp) const { return ((XIsZero() && opp.XIsZero()) || (std::signbit(m_X) != std::signbit(opp.m_X))) && ((YIsZero() && opp.YIsZero()) || (std::signbit(m_Y) != std::signbit(opp.m_Y))); }
 #pragma endregion
 
 #pragma region Magnitude
@@ -182,26 +163,26 @@ namespace RTE {
 		/// </summary>
 		/// <param name="newMag">A float value that the magnitude will be set to.</param>
 		/// <returns>A reference to this after the change.</returns>
-		Vector & SetMagnitude(float newMag);
+		Vector & SetMagnitude(const float newMag);
 
 		/// <summary>
 		/// Caps the magnitude of this Vector to a max value and keeps its angle intact.
 		/// </summary>
 		/// <param name="capMag">A float value that the magnitude will be capped by.</param>
 		/// <returns>A reference to this after the change.</returns>
-		Vector & CapMagnitude(float capMag);
+		Vector & CapMagnitude(const float capMag);
 
 		/// <summary>
 		/// Returns a Vector that has the same direction as this but with a magnitude of 1.0.
 		/// </summary>
-		/// <returns></returns>
+		/// <returns>A normalized copy of this vector.</returns>
 		Vector GetNormalized() const { return *this / GetMagnitude(); }
 
 		/// <summary>
 		/// Scales this vector to have the same direction but a magnitude of 1.0.
 		/// </summary>
 		/// <returns>Vector reference to this after the operation.</returns>
-		Vector & Normalize() { return *this /= GetMagnitude(); }
+		Vector & Normalize() { *this = GetNormalized(); return *this; }
 #pragma endregion
 
 #pragma region Rotation
@@ -222,14 +203,14 @@ namespace RTE {
 		/// </summary>
 		/// <param name="angle">The angle in radians to rotate by. Positive angles rotate counter-clockwise, and negative angles clockwise.</param>
 		/// <returns>This vector, rotated.</returns>
-		Vector & RadRotate(float angle);
+		Vector & RadRotate(const float angle);
 
 		/// <summary>
 		/// Rotate this Vector relatively by an angle in degrees.
 		/// </summary>
 		/// <param name="angle">The angle in degrees to rotate by. Positive angles rotate counter-clockwise, and negative angles clockwise.</param>
 		/// <returns>This vector, rotated.</returns>
-		Vector & DegRotate(float angle) { return RadRotate(angle * c_PI / 180.0F); }
+		Vector & DegRotate(const float angle) { return RadRotate(angle * c_PI / 180.0F); }
 
 		/// <summary>
 		/// Set this Vector to an absolute rotation based on the absolute rotation of another Vector.
@@ -255,46 +236,46 @@ namespace RTE {
 		/// <summary>
 		/// Rounds the X and Y values of this Vector upwards. E.g. 0.49 -> 0.0 and 0.5 -> 1.0.
 		/// </summary>
-		void Round() { m_X = std::roundf(m_X); m_Y = std::roundf(m_Y); }
+		void Round() { *this = GetRounded(); }
 
 		/// <summary>
 		/// Sets the X and Y of this Vector to the nearest half value. E.g. 1.0 -> 1.5 and 0.9 -> 0.5.
 		/// </summary>
-		void ToHalf() { m_X = std::roundf(m_X * 2) / 2; m_Y = std::roundf(m_Y * 2) / 2; }
+		void ToHalf() { m_X = std::round(m_X * 2) / 2; m_Y = std::round(m_Y * 2) / 2; }
 
 		/// <summary>
 		/// Sets the X and Y of this Vector to the greatest integers that are not greater than their original values. E.g. -1.02 becomes -2.0.
 		/// </summary>
-		void Floor() { m_X = std::floor(m_X); m_Y = std::floor(m_Y); }
+		void Floor() { *this = GetFloored(); }
 
 		/// <summary>
 		/// Sets the X and Y of this Vector to the lowest integers that are not less than their original values. E.g. -1.02 becomes -1.0.
 		/// </summary>
-		void Ceiling() { m_X = std::ceil(m_X); m_Y = std::ceil(m_Y); }
+		void Ceiling() { *this = GetCeilinged(); }
 
 		/// <summary>
 		/// Returns a rounded copy of this Vector. Does not alter this Vector.
 		/// </summary>
 		/// <returns>A rounded copy of this Vector.</returns>
-		Vector GetRounded() const { Vector returnVector = *this; returnVector.Round();  return returnVector; }
+		Vector GetRounded() const { return Vector(std::round(m_X), std::round(m_Y)); }
 
 		/// <summary>
 		/// Returns the rounded integer X value of this Vector.
 		/// </summary>
 		/// <returns>An int value that represents the X value of this Vector.</returns>
-		int GetRoundIntX() const { return static_cast<int>(std::roundf(m_X)); }
+		int GetRoundIntX() const { return static_cast<int>(std::round(m_X)); }
 
 		/// <summary>
 		/// Returns the rounded integer Y value of this Vector.
 		/// </summary>
 		/// <returns>An int value that represents the Y value of this Vector.</returns>
-		int GetRoundIntY() const { return static_cast<int>(std::roundf(m_Y)); }
+		int GetRoundIntY() const { return static_cast<int>(std::round(m_Y)); }
 
 		/// <summary>
 		/// Returns a floored copy of this Vector. Does not alter this Vector.
 		/// </summary>
 		/// <returns>A floored copy of this Vector.</returns>
-		Vector GetFloored() const { Vector returnVector = *this; returnVector.Floor(); return returnVector; }
+		Vector GetFloored() const { return Vector(std::floor(m_X), std::floor(m_Y)); }
 
 		/// <summary>
 		/// Returns the greatest integer that is not greater than the X value of this Vector.
@@ -312,7 +293,7 @@ namespace RTE {
 		/// Returns a ceilinged copy of this Vector. Does not alter this Vector.
 		/// </summary>
 		/// <returns>A ceilinged copy of this Vector.</returns>
-		Vector GetCeilinged() const { Vector returnVector = *this; returnVector.Ceiling(); return returnVector; }
+		Vector GetCeilinged() const { return Vector(std::ceil(m_X), std::ceil(m_Y)); }
 
 		/// <summary>
 		/// Returns the lowest integer that is not less than the X value of this Vector.
@@ -333,24 +314,17 @@ namespace RTE {
 		/// </summary>
 		/// <param name="rhs">The Vector which will be the right hand side operand of the dot product operation.</param>
 		/// <returns>The resulting dot product scalar float.</returns>
-		float Dot(const Vector &rhs) { return (m_X * rhs.m_X) + (m_Y * rhs.m_Y); }
+		float Dot(const Vector &rhs) const { return (m_X * rhs.m_X) + (m_Y * rhs.m_Y); }
 
 		/// <summary>
 		/// Returns the 2D cross product of this Vector and the passed in Vector. This is really the area of the parallelogram that the two vectors form.
 		/// </summary>
 		/// <param name="rhs">The Vector which will be the right hand side operand of the cross product operation.</param>
 		/// <returns>The resulting 2D cross product parallelogram area.</returns>
-		float Cross(const Vector &rhs) { return (m_X * rhs.m_Y) - (rhs.m_X * m_Y); }
+		float Cross(const Vector &rhs) const { return (m_X * rhs.m_Y) - (rhs.m_X * m_Y); }
 #pragma endregion
 
 #pragma region Operator Overloads
-		/// <summary>
-		/// An assignment operator for setting one Vector equal to another.
-		/// </summary>
-		/// <param name="rhs">A Vector reference.</param>
-		/// <returns>A reference to the changed Vector.</returns>
-		Vector & operator=(const Vector &rhs);
-
 		/// <summary>
 		/// An assignment operator for setting this Vector equal to the average of an std::deque of Vectors.
 		/// </summary>
@@ -362,7 +336,7 @@ namespace RTE {
 		/// Unary negation overload for single Vectors.
 		/// </summary>
 		/// <returns>The resulting Vector.</returns>
-		Vector operator-() { Vector returnVector(-m_X, -m_Y); return returnVector; }
+		Vector operator-() { return Vector(-m_X, -m_Y); }
 
 		/// <summary>
 		/// An equality operator for testing if any two Vectors are equal.
@@ -378,7 +352,7 @@ namespace RTE {
 		/// <param name="lhs">A Vector reference as the left hand side operand.</param>
 		/// <param name="rhs">A Vector reference as the right hand side operand.</param>
 		/// <returns>A boolean indicating whether the two operands are unequal or not.</returns>
-		friend bool operator!=(const Vector &lhs, const Vector &rhs) { return lhs.m_X != rhs.m_X || lhs.m_Y != rhs.m_Y; }
+		friend bool operator!=(const Vector &lhs, const Vector &rhs) { return !(lhs==rhs); }
 
 		/// <summary>
 		/// A stream insertion operator for sending a Vector to an output stream.
@@ -388,13 +362,6 @@ namespace RTE {
 		/// <returns>An ostream reference for further use in an expression.</returns>
 		friend std::ostream & operator<<(std::ostream &stream, const Vector &operand) { stream << "{" << operand.m_X << ", " << operand.m_Y << "}"; return stream; }
 
-		/// <summary>
-		/// Addition operator overload for a Vector and a float.
-		/// </summary>
-		/// <param name="rhs">A float reference as the right hand side operand.</param>
-		/// <returns>The resulting Vector.</returns>
-		Vector operator+(const float &rhs) const { Vector returnVector(m_X + rhs, m_Y + rhs); return returnVector; }
-
 		/// <summary>
 		/// Addition operator overload for Vectors.
 		/// </summary>
@@ -440,7 +407,7 @@ namespace RTE {
 		/// <returns>The resulting Vector.</returns>
 		Vector operator/(const float &rhs) const {
 			Vector returnVector(0, 0);
-			if (rhs) { returnVector.SetXY(m_X / rhs, m_Y / rhs); }
+			if (rhs != 0) { returnVector.SetXY(m_X / rhs, m_Y / rhs); }
 			return returnVector;
 		}
 
@@ -452,7 +419,7 @@ namespace RTE {
 		/// <returns>The resulting Vector.</returns>
 		friend Vector operator/(const Vector &lhs, const Vector &rhs) {
 			Vector returnVector(0, 0);
-			if (rhs.m_X && rhs.m_Y) { returnVector.SetXY(lhs.m_X / rhs.m_X, lhs.m_Y / rhs.m_Y); }
+			if (rhs.m_X != 0 && rhs.m_Y != 0) { returnVector.SetXY(lhs.m_X / rhs.m_X, lhs.m_Y / rhs.m_Y); }
 			return returnVector;
 		}
 
@@ -506,7 +473,7 @@ namespace RTE {
 		/// </summary>
 		/// <param name="rhs">A float reference as the right hand side operand.</param>
 		/// <returns>A reference to the resulting Vector.</returns>
-		Vector & operator/=(const float &rhs) { if (rhs) { m_X /= rhs; m_Y /= rhs; } return *this; }
+		Vector & operator/=(const float &rhs) { if (rhs != 0) { m_X /= rhs; m_Y /= rhs; } return *this; }
 
 		/// <summary>
 		/// Self-division operator overload for Vectors.
@@ -515,8 +482,8 @@ namespace RTE {
 		/// <param name="rhs">A Vector reference as the right hand side operand.</param>
 		/// <returns>A reference to the resulting Vector (the left one).</returns>
 		friend Vector & operator/=(Vector &lhs, const Vector &rhs) {
-			if (rhs.m_X) { lhs.m_X /= rhs.m_X; }
-			if (rhs.m_Y) { lhs.m_Y /= rhs.m_Y; }
+			if (rhs.m_X != 0) { lhs.m_X /= rhs.m_X; }
+			if (rhs.m_Y != 0) { lhs.m_Y /= rhs.m_Y; }
 			return lhs;
 		}
 
@@ -546,13 +513,6 @@ namespace RTE {
 	protected:
 
 		static const std::string c_ClassName; //!< A string with the friendly-formatted type name of this.
-
-	private:
-
-		/// <summary>
-		/// Clears all the member variables of this Vector, effectively resetting the members of this abstraction level only.
-		/// </summary>
-		void Clear() { m_X = m_Y = 0; }
 	};
 }
 #endif