RoboidControl-cpp/Vector2.h

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0.If a copy of the MPL was not distributed with this
// file, You can obtain one at https ://mozilla.org/MPL/2.0/.

#ifndef VECTOR2_H
#define VECTOR2_H

extern "C" {
	/// <summary>
	/// 2-dimensional Vector representation
	/// </summary>
	/// This is a C-style implementation
	/// This uses the right-handed coordinate system.
	typedef struct Vec2 {
		/// <summary>
		/// The right axis of the vector
		/// </summary>
		float x;
		/// <summary>
		/// The upward/forward axis of the vector
		/// </summary>
		float y;

	} Vec2;
}

/// <summary>
/// A 2-dimensional vector
/// </summary>
/// This uses the right-handed coordinate system.
struct Vector2 : Vec2 {
public:
	/// <summary>
	/// Create a new 2-dimensinal zero vector
	/// </summary>
	Vector2();
	/// <summary>
	/// Create a new 2-dimensional vector
	/// </summary>
	/// <param name="x">x axis value</param>
	/// <param name="y">y axis value</param>
	Vector2(float x, float y);
	/// <summary>
	/// Create a vector from C-style Vec2
	/// </summary>
	/// <param name="v">The C-style Vec</param>
	Vector2(Vec2 v);

	~Vector2();

	/// <summary>
	/// A vector with zero for all axis
	/// </summary>
	const static Vector2 zero;
	/// <summary>
	/// A vector with values (1, 1)
	/// </summary>
	const static Vector2 one;
	/// <summary>
	/// A vector with values (1, 0)
	/// </summary>
/// 
	const static Vector2 right;
	/// <summary>
	/// A vector3 with values (-1, 0)
	/// </summary>
	const static Vector2 left;
	/// <summary>
	/// A vector with values (0, 1)
	/// </summary>
	const static Vector2 up;
	/// <summary>
	/// A vector with values (0, -1)
	/// </summary>
	const static Vector2 down;
	/// <summary>
	/// A vector with values (0, 1)
	/// </summary>
	const static Vector2 forward;
	/// <summary>
	/// A vector with values (0, -1)
	/// </summary>
	const static Vector2 back;

	/// <summary>
	/// The length of a vector
	/// </summary>
	/// <param name="vector">The vector for which you need the length</param>
	/// <returns>The length of the given vector</returns>
	static float Magnitude(const Vector2& vector);
	/// <summary>
	/// The length of this vector
	/// </summary>
	/// <returns>The length of this vector</returns>
	float magnitude() const;
	/// <summary>
	/// The squared length of a vector
	/// </summary>
	/// <param name="vector">The vector for which you need the squared
	/// length</param> <returns>The squatred length</returns> The squared length
	/// is computationally simpler than the real length. Think of Pythagoras A^2 +
	/// B^2 = C^2. This leaves out the calculation of the squared root of C.
	static float SqrMagnitude(const Vector2& vector);
	/// <summary>
	/// The squared length of this vector
	/// </summary>
	/// <returns>The squared length</returns>
	/// The squared length is computationally simpler than the real length.
	/// Think of Pythagoras A^2 + B^2 = C^2.
	/// This leaves out the calculation of the squared root of C.
	float sqrMagnitude() const;
	/// <summary>
	/// Connvert a vector to a length of 1
	/// </summary>
	/// <param name="vector">The vector to convert</param>
	/// <returns>The vector with length 1</returns>
	static Vector2 Normalize(Vector2 vector);
	/// <summary>
	/// Convert the vector to a length of a
	/// </summary>
	/// <returns>The vector with length 1</returns>
	Vector2 normalized() const;

	/// <summary>
	/// Negate the vector
	/// </summary>
	/// <returns>The negated vector</returns>
	/// This will result in a vector pointing in the opposite direction
	Vector2 operator-();
	/// <summary>
	/// Subtract a vector from this vector
	/// </summary>
	/// <param name="vector">The vector to subtract from this vector</param>
	/// <returns>The result of the subtraction</returns>
	Vector2 operator-(const Vector2& vector) const;

	/// <summary>
	/// Add another vector to this vector
	/// </summary>
	/// <param name="vector2">The vector to add</param>
	/// <returns>The result of adding the vector</returns>
	Vector2 operator+(const Vector2& vector2) const;

	/// <summary>
	/// Scale a vector using another vector
	/// </summary>
	/// <param name="vector1">The vector to scale</param>
	/// <param name="vector2">A vector with scaling factors</param>
	/// <returns>The scaled vector</returns>
	/// Each component of the vector v1 will be multiplied with the
	/// component from the scaling vector v2.
	static Vector2 Scale(const Vector2& vector1, const Vector2& vector2);
	/// <summary>
	/// Scale a vector uniformly up
	/// </summary>
	/// <param name="factor">The scaling factor</param>
	/// <returns>The scaled vector</returns>
	/// Each component of the vector will be multipled with the same factor.
	Vector2 operator*(float factor) const;
	/// <summary>
	/// Scale a vector uniformy down
	/// </summary>
	/// <param name="factor">The scaling factor</param>
	/// <returns>The scaled vector</returns>
	/// Each componet of the vector will be divided by the same factor.
	Vector2 operator/(const float& factor);

	/// <summary>
	/// The dot product of two vectors
	/// </summary>
	/// <param name="vector1">The first vector</param>
	/// <param name="vector2">The second vector</param>
	/// <returns>The dot product of the two vectors</returns>
	static float Dot(const Vector2& vector1, const Vector2& vector2);

	/// <summary>
	/// Check is this vector is equal to the given vector
	/// </summary>
	/// <param name="vector">The vector to check against</param>
	/// <returns>True if it is identical to the given vector</returns>
	/// Note this uses float comparison to check equality which
	/// may have strange effects. Equality on float should be avoided.
	bool operator==(const Vector2& vector);

	/// <summary>
	/// The distance between two vectors
	/// </summary>
	/// <param name="vector1">The first vector</param>
	/// <param name="vector2">The second vectors</param>
	/// <returns>The distance between the two vectors</returns>
	static float Distance(const Vector2& vector1, const Vector2& vector2);

	/// <summary>
	/// Calculate the angle between two vectors
	/// </summary>
	/// <param name="vector1">The first vector</param>
	/// <param name="vector2">The second vector</param>
	/// <returns>The angle</returns>
	/// This reterns an unsigned angle which is the shortest distance
	/// between the two vectors. Use Vector3::SignedAngle if a
	/// signed angle is needed.
	static float Angle(Vector2 vector1, Vector2 vector2);

	/// <summary>
	/// Calculate the angle between two vectors rotation around an axis.
	/// </summary>
	/// <param name="from">The starting vector</param>
	/// <param name="to">The ending vector</param>
	/// <param name="axis">The axis to rotate around</param>
	/// <returns>The signed angle</returns>
	static float SignedAngle(Vector2 from, Vector2 to);

	/// <summary>
	/// Rotate the vector
	/// </summary>
	/// <param name="v">The vector to rotate</param>
	/// <param name="angle">Angle in radias to rotate</param>
	/// <returns>The rotated vector</returns>
	static Vector2 Rotate(Vector2 v, float angle);

	/// <summary>
	/// Lerp between two vectors
	/// </summary>
	/// <param name="from">The from vector</param>
	/// <param name="to">The to vector</param>
	/// <param name="f">The interpolation distance (0..1)</param>
	/// <returns>The lerped vector</returns>
	/// The factor f is unclamped. Value 0 matches the *from* vector, Value 1
	/// matches the *to* vector Value -1 is *from* vector minus the difference
	/// between *from* and *to* etc.
	static Vector2 Lerp(Vector2 from, Vector2 to, float f);

	static float ToFactor(Vector2 a, Vector2 b);
};

#endif