/// <summary>
/// Initializes a new instance of the <see cref="OrientedBox"/> class using given center point, axes and extents.
/// </summary>
/// <param name="center">The center of the box.</param>
/// <param name="axis1">The first axis.</param>
/// <param name="axis2">The second axis.</param>
/// <param name="extent1">The extent on the first axis.</param>
/// <param name="extent2">The extent on the second axis.</param>
public OrientedBox(Vector2F center, Vector2F axis1, Vector2F axis2, float extent1, float extent2)
{
_center = center;
_axis1 = axis1;
_axis2 = axis2;
_extent1 = extent1;
_extent2 = extent2;
}
/// <summary>
/// Initializes a new instance of the <see cref="OrientedBox"/> class using given center point, axes and extents.
/// </summary>
/// <param name="center">The center of the box.</param>
/// <param name="axes">The axes of the box.</param>
/// <param name="extents">The extent values of the box..</param>
public OrientedBox(Vector2F center, Vector2F[] axes, float[] extents)
{
Debug.Assert(axes.Length >= 2);
Debug.Assert(extents.Length >= 2);
_center = center;
_axis1 = axes[0];
_axis2 = axes[1];
_extent1 = extents[0];
_extent2 = extents[1];
}
/// <summary>
/// Subtracts a vector from a scalar.
/// </summary>
/// <param name="v">A <see cref="Vector2F"/> instance.</param>
/// <param name="s">A scalar.</param>
/// <returns>A new <see cref="Vector2F"/> instance containing the difference.</returns>
/// <remarks>
/// result[i] = s - v[i]
/// </remarks>
public static Vector2F Subtract(float s, Vector2F v)
{
return(new Vector2F(s - v.X, s - v.Y));
}
/// <summary>
/// convert a float version Vector2F into a double version Vector2D
/// </summary>
/// <param name="vec">Vector2F to convert</param>
/// <returns>Vector2D</returns>
static public Vector2D Vector2FToVector2D(Vector2F vec)
{
return new Vector2D((double)vec.X, (double)vec.Y);
}
/// <summary>
/// Tests whether two vectors are approximately equal given a tolerance value.
/// </summary>
/// <param name="left">A <see cref="Vector2F"/> instance.</param>
/// <param name="right">A <see cref="Vector2F"/> instance.</param>
/// <param name="tolerance">The tolerance value used to test approximate equality.</param>
/// <returns><see langword="true"/> if the two vectors are approximately equal; otherwise, <see langword="false"/>.</returns>
public static bool ApproxEqual(Vector2F left, Vector2F right, float tolerance)
{
return
(
(System.Math.Abs(left.X - right.X) <= tolerance) &&
(System.Math.Abs(left.Y - right.Y) <= tolerance)
);
}
/// <summary>
/// Calculates the dot product of two vectors.
/// </summary>
/// <param name="left">A <see cref="Vector2F"/> instance.</param>
/// <param name="right">A <see cref="Vector2F"/> instance.</param>
/// <returns>The dot product value.</returns>
public static float DotProduct(Vector2F left, Vector2F right)
{
return (left.X * right.X) + (left.Y * right.Y);
}
/// <summary>
/// Divides a vector by a scalar.
/// </summary>
/// <param name="vector">A <see cref="Vector2F"/> instance.</param>
/// <param name="scalar">A scalar</param>
/// <param name="result">A <see cref="Vector2F"/> instance to hold the result.</param>
/// <remarks>
/// result[i] = vector[i] / scalar
/// </remarks>
public static void Divide(Vector2F vector, float scalar, ref Vector2F result)
{
result.X = vector.X / scalar;
result.Y = vector.Y / scalar;
}
/// <summary>
/// Divides a vector by another vector.
/// </summary>
/// <param name="left">A <see cref="Vector2F"/> instance.</param>
/// <param name="right">A <see cref="Vector2F"/> instance.</param>
/// <returns>A new <see cref="Vector2F"/> containing the quotient.</returns>
/// <remarks>
/// result[i] = left[i] / right[i].
/// </remarks>
public static Vector2F Divide(Vector2F left, Vector2F right)
{
return new Vector2F(left.X / right.X, left.Y / right.Y);
}
/// <summary>
/// Divides a vector by another vector.
/// </summary>
/// <param name="u">A <see cref="Vector2F"/> instance.</param>
/// <param name="v">A <see cref="Vector2F"/> instance.</param>
/// <param name="w">A <see cref="Vector2F"/> instance to hold the result.</param>
/// <remarks>
/// w[i] = u[i] / v[i]
/// </remarks>
public static void Divide(Vector2F u, Vector2F v, ref Vector2F w)
{
w.X = u.X / v.X;
w.Y = u.Y / v.Y;
}
/// <summary>
/// Divides a scalar by a vector.
/// </summary>
/// <param name="v">A <see cref="Vector2F"/> instance.</param>
/// <param name="s">A scalar</param>
/// <returns>A new <see cref="Vector2F"/> containing the quotient.</returns>
/// <remarks>
/// result[i] = s / v[i]
/// </remarks>
public static Vector2F Divide(float s, Vector2F v)
{
return(new Vector2F(s / v.X, s / v.Y));
}
/// <summary>
/// Divides a vector by a scalar.
/// </summary>
/// <param name="v">A <see cref="Vector2F"/> instance.</param>
/// <param name="s">A scalar</param>
/// <returns>A new <see cref="Vector2F"/> containing the quotient.</returns>
/// <remarks>
/// result[i] = v[i] / s;
/// </remarks>
public static Vector2F Divide(Vector2F v, float s)
{
return(new Vector2F(v.X / s, v.Y / s));
}
/// <summary>
/// Divides a vector by another vector.
/// </summary>
/// <param name="u">A <see cref="Vector2F"/> instance.</param>
/// <param name="v">A <see cref="Vector2F"/> instance.</param>
/// <returns>A new <see cref="Vector2F"/> containing the quotient.</returns>
/// <remarks>
/// result[i] = u[i] / v[i].
/// </remarks>
public static Vector2F Divide(Vector2F u, Vector2F v)
{
return(new Vector2F(u.X / v.X, u.Y / v.Y));
}
/// <summary>
/// Subtracts a scalar from a vector and put the result into another vector.
/// </summary>
/// <param name="u">A <see cref="Vector2F"/> instance.</param>
/// <param name="s">A scalar.</param>
/// <param name="v">A <see cref="Vector2F"/> instance to hold the result.</param>
/// <remarks>
/// v[i] = s - u[i]
/// </remarks>
public static void Subtract(float s, Vector2F u, ref Vector2F v)
{
v.X = s - u.X;
v.Y = s - u.Y;
}
/// <summary>
/// Subtracts a vector from a scalar and put the result into another vector.
/// </summary>
/// <param name="u">A <see cref="Vector2F"/> instance.</param>
/// <param name="s">A scalar.</param>
/// <param name="v">A <see cref="Vector2F"/> instance to hold the result.</param>
/// <remarks>
/// v[i] = u[i] - s
/// </remarks>
public static void Subtract(Vector2F u, float s, ref Vector2F v)
{
v.X = u.X - s;
v.Y = u.Y - s;
}
/// <summary>
/// Subtracts a vector from a second vector and puts the result into a third vector.
/// </summary>
/// <param name="u">A <see cref="Vector2F"/> instance.</param>
/// <param name="v">A <see cref="Vector2F"/> instance</param>
/// <param name="w">A <see cref="Vector2F"/> instance to hold the result.</param>
/// <remarks>
/// w[i] = v[i] - w[i].
/// </remarks>
public static void Subtract(Vector2F u, Vector2F v, ref Vector2F w)
{
w.X = u.X - v.X;
w.Y = u.Y - v.Y;
}
/// <summary>
/// Subtracts a vector from a scalar.
/// </summary>
/// <param name="vector">A <see cref="Vector2F"/> instance.</param>
/// <param name="scalar">A single-precision floating-point number.</param>
/// <returns>A new <see cref="Vector2F"/> instance containing the difference.</returns>
/// <remarks>
/// result[i] = scalar - vector[i]
/// </remarks>
public static Vector2F Subtract(float scalar, Vector2F vector)
{
return new Vector2F(scalar - vector.X, scalar - vector.Y);
}
/// <summary>
/// Subtracts a vector from a scalar and put the result into another vector.
/// </summary>
/// <param name="vector">A <see cref="Vector2F"/> instance.</param>
/// <param name="scalar">A single-precision floating-point number.</param>
/// <param name="result">A <see cref="Vector2F"/> instance to hold the result.</param>
/// <remarks>
/// result[i] = vector[i] - scalar
/// </remarks>
public static void Subtract(Vector2F vector, float scalar, ref Vector2F result)
{
result.X = vector.X - scalar;
result.Y = vector.Y - scalar;
}
/// <summary>
/// Divides a vector by a scalar.
/// </summary>
/// <param name="u">A <see cref="Vector2F"/> instance.</param>
/// <param name="s">A scalar</param>
/// <param name="v">A <see cref="Vector2F"/> instance to hold the result.</param>
/// <remarks>
/// v[i] = u[i] / s
/// </remarks>
public static void Divide(Vector2F u, float s, ref Vector2F v)
{
v.X = u.X / s;
v.Y = u.Y / s;
}
/// <summary>
/// Divides a scalar by a vector.
/// </summary>
/// <param name="vector">A <see cref="Vector2F"/> instance.</param>
/// <param name="scalar">A scalar</param>
/// <returns>A new <see cref="Vector2F"/> containing the quotient.</returns>
/// <remarks>
/// result[i] = scalar / vector[i]
/// </remarks>
public static Vector2F Divide(float scalar, Vector2F vector)
{
return new Vector2F(scalar / vector.X, scalar / vector.Y);
}
/// <summary>
/// Divides a scalar by a vector.
/// </summary>
/// <param name="u">A <see cref="Vector2F"/> instance.</param>
/// <param name="s">A scalar</param>
/// <param name="v">A <see cref="Vector2F"/> instance to hold the result.</param>
/// <remarks>
/// v[i] = s / u[i]
/// </remarks>
public static void Divide(float s, Vector2F u, ref Vector2F v)
{
v.X = s / u.X;
v.Y = s / u.Y;
}
/// <summary>
/// Multiplies a vector by a scalar.
/// </summary>
/// <param name="vector">A <see cref="Vector2F"/> instance.</param>
/// <param name="scalar">A single-precision floating-point number.</param>
/// <returns>A new <see cref="Vector2F"/> containing the result.</returns>
public static Vector2F Multiply(Vector2F vector, float scalar)
{
return new Vector2F(vector.X * scalar, vector.Y * scalar);
}
/// <summary>
/// Multiplies a vector by a scalar.
/// </summary>
/// <param name="u">A <see cref="Vector2F"/> instance.</param>
/// <param name="s">A scalar.</param>
/// <returns>A new <see cref="Vector2F"/> containing the result.</returns>
public static Vector2F Multiply(Vector2F u, float s)
{
return(new Vector2F(u.X * s, u.Y * s));
}
/// <summary>
/// Negates a vector.
/// </summary>
/// <param name="vector">A <see cref="Vector2F"/> instance.</param>
/// <returns>A new <see cref="Vector2F"/> instance containing the negated values.</returns>
public static Vector2F Negate(Vector2F vector)
{
return new Vector2F(-vector.X, -vector.Y);
}
/// <summary>
/// Multiplies a vector by a scalar and put the result in another vector.
/// </summary>
/// <param name="u">A <see cref="Vector2F"/> instance.</param>
/// <param name="s">A scalar.</param>
/// <param name="v">A <see cref="Vector2F"/> instance to hold the result.</param>
public static void Multiply(Vector2F u, float s, ref Vector2F v)
{
v.X = u.X * s;
v.Y = u.Y * s;
}
/// <summary>
/// Computes the box vertices.
/// </summary>
/// <returns>An array of <see cref="Vector2F"/> containing the box vertices.</returns>
public Vector2F[] ComputeVertices()
{
Vector2F[] vertices = new Vector2F[4];
Vector2F[] AxisExtents = new Vector2F[2]
{
Axis1*Extent1, Axis2*Extent2
};
vertices[0] = Center - AxisExtents[0] - AxisExtents[1];
vertices[1] = Center + AxisExtents[0] - AxisExtents[1];
vertices[2] = Center + AxisExtents[0] + AxisExtents[1];
vertices[3] = Center - AxisExtents[0] + AxisExtents[1];
return vertices;
}
/// <summary>
/// Calculates the dot product of two vectors.
/// </summary>
/// <param name="u">A <see cref="Vector2F"/> instance.</param>
/// <param name="v">A <see cref="Vector2F"/> instance.</param>
/// <returns>The dot product value.</returns>
public static float DotProduct(Vector2F u, Vector2F v)
{
return((u.X * v.X) + (u.Y * v.Y));
}
/// <summary>
/// Initializes a new instance of the <see cref="Circle"/> class using center and radius values.
/// </summary>
/// <param name="center">The circle's center point.</param>
/// <param name="radius">The circle's radius.</param>
public Circle(Vector2F center, float radius)
{
_c = center;
_r = radius;
}
/// <summary>
/// Calculates the Kross product of two vectors.
/// </summary>
/// <param name="u">A <see cref="Vector2D"/> instance.</param>
/// <param name="v">A <see cref="Vector2D"/> instance.</param>
/// <returns>The Kross product value.</returns>
/// <remarks>
/// <p>
/// The Kross product is defined as:
/// Kross(u,v) = u.X*v.Y - u.Y*v.X.
/// </p>
/// <p>
/// The operation is related to the cross product in 3D given by (x0, y0, 0) X (x1, y1, 0) = (0, 0, Kross((x0, y0), (x1, y1))).
/// The operation has the property that Kross(u, v) = -Kross(v, u).
/// </p>
/// </remarks>
public static float KrossProduct(Vector2F u, Vector2F v)
{
return(u.X * v.Y - u.Y * v.X);
}
/// <summary>
/// Transforms a given vector by a matrix and put the result in a vector.
/// </summary>
/// <param name="matrix">A <see cref="Matrix2F"/> instance.</param>
/// <param name="vector">A <see cref="Vector2F"/> instance.</param>
/// <param name="result">A <see cref="Vector2F"/> instance to hold the result.</param>
public static void Transform(Matrix2F matrix, Vector2F vector, ref Vector2F result)
{
result.X = (matrix.M11 * vector.X) + (matrix.M12 * vector.Y);
result.Y = (matrix.M21 * vector.X) + (matrix.M22 * vector.Y);
}
/// <summary>
/// Negates a vector.
/// </summary>
/// <param name="v">A <see cref="Vector2F"/> instance.</param>
/// <returns>A new <see cref="Vector2F"/> instance containing the negated values.</returns>
public static Vector2F Negate(Vector2F v)
{
return(new Vector2F(-v.X, -v.Y));
}
/// <summary>
/// Subtracts a scalar from a vector.
/// </summary>
/// <param name="vector">A <see cref="Vector2F"/> instance.</param>
/// <param name="scalar">A single-precision floating-point number.</param>
/// <returns>A new <see cref="Vector2F"/> instance containing the difference.</returns>
/// <remarks>
/// result[i] = vector[i] - scalar
/// </remarks>
public static Vector2F Subtract(Vector2F vector, float scalar)
{
return new Vector2F(vector.X - scalar, vector.Y - scalar);
}
/// <summary>
/// Tests whether two vectors are approximately equal using default tolerance value.
/// </summary>
/// <param name="v">A <see cref="Vector2F"/> instance.</param>
/// <param name="u">A <see cref="Vector2F"/> instance.</param>
/// <returns><see langword="true"/> if the two vectors are approximately equal; otherwise, <see langword="false"/>.</returns>
public static bool ApproxEqual(Vector2F v, Vector2F u)
{
return(ApproxEqual(v, u, MathFunctions.EpsilonF));
}
/// <summary>
/// Subtracts a vector from a second vector and puts the result into a third vector.
/// </summary>
/// <param name="left">A <see cref="Vector2F"/> instance.</param>
/// <param name="right">A <see cref="Vector2F"/> instance</param>
/// <param name="result">A <see cref="Vector2F"/> instance to hold the result.</param>
/// <remarks>
/// result[i] = left[i] - right[i].
/// </remarks>
public static void Subtract(Vector2F left, Vector2F right, ref Vector2F result)
{
result.X = left.X - right.X;
result.Y = left.Y - right.Y;
}
/// <summary>
/// Negates the values of the vector.
/// </summary>
/// <param name="v">A <see cref="Vector2F"/> instance.</param>
/// <returns>A new <see cref="Vector2F"/> instance containing the negated values.</returns>
public static Vector2F operator-(Vector2F v)
{
return(Vector2F.Negate(v));
}
/// <summary>
/// Subtracts a scalar from a vector and put the result into another vector.
/// </summary>
/// <param name="vector">A <see cref="Vector2F"/> instance.</param>
/// <param name="scalar">A single-precision floating-point number.</param>
/// <param name="result">A <see cref="Vector2F"/> instance to hold the result.</param>
/// <remarks>
/// result[i] = scalar - vector[i]
/// </remarks>
public static void Subtract(float scalar, Vector2F vector, ref Vector2F result)
{
result.X = scalar - vector.X;
result.Y = scalar - vector.Y;
}
/// <summary>
/// Adds two vectors.
/// </summary>
/// <param name="u">A <see cref="Vector2F"/> instance.</param>
/// <param name="v">A <see cref="Vector2F"/> instance.</param>
/// <returns>A new <see cref="Vector2F"/> instance containing the sum.</returns>
public static Vector2F operator+(Vector2F u, Vector2F v)
{
return(Vector2F.Add(u, v));
}
/// <summary>
/// Divides a vector by a scalar.
/// </summary>
/// <param name="vector">A <see cref="Vector2F"/> instance.</param>
/// <param name="scalar">A scalar</param>
/// <returns>A new <see cref="Vector2F"/> containing the quotient.</returns>
/// <remarks>
/// result[i] = vector[i] / scalar;
/// </remarks>
public static Vector2F Divide(Vector2F vector, float scalar)
{
return new Vector2F(vector.X / scalar, vector.Y / scalar);
}
/// <summary>
/// Adds a vector and a scalar.
/// </summary>
/// <param name="v">A <see cref="Vector2F"/> instance.</param>
/// <param name="s">A scalar.</param>
/// <returns>A new <see cref="Vector2F"/> instance containing the sum.</returns>
public static Vector2F operator+(float s, Vector2F v)
{
return(Vector2F.Add(v, s));
}
/// <summary>
/// Divides a vector by another vector.
/// </summary>
/// <param name="left">A <see cref="Vector2F"/> instance.</param>
/// <param name="right">A <see cref="Vector2F"/> instance.</param>
/// <param name="result">A <see cref="Vector2F"/> instance to hold the result.</param>
/// <remarks>
/// result[i] = left[i] / right[i]
/// </remarks>
public static void Divide(Vector2F left, Vector2F right, ref Vector2F result)
{
result.X = left.X / right.X;
result.Y = left.Y / right.Y;
}
/// <summary>
/// Subtracts a vector from a vector.
/// </summary>
/// <param name="u">A <see cref="Vector2F"/> instance.</param>
/// <param name="v">A <see cref="Vector2F"/> instance.</param>
/// <returns>A new <see cref="Vector2F"/> instance containing the difference.</returns>
/// <remarks>
/// result[i] = v[i] - w[i].
/// </remarks>
public static Vector2F operator-(Vector2F u, Vector2F v)
{
return(Vector2F.Subtract(u, v));
}
/// <summary>
/// Divides a scalar by a vector.
/// </summary>
/// <param name="vector">A <see cref="Vector2F"/> instance.</param>
/// <param name="scalar">A scalar</param>
/// <param name="result">A <see cref="Vector2F"/> instance to hold the result.</param>
/// <remarks>
/// result[i] = scalar / vector[i]
/// </remarks>
public static void Divide(float scalar, Vector2F vector, ref Vector2F result)
{
result.X = scalar / vector.X;
result.Y = scalar / vector.Y;
}
/// <summary>
/// Subtracts a scalar from a vector.
/// </summary>
/// <param name="v">A <see cref="Vector2F"/> instance.</param>
/// <param name="s">A scalar.</param>
/// <returns>A new <see cref="Vector2F"/> instance containing the difference.</returns>
/// <remarks>
/// result[i] = v[i] - s
/// </remarks>
public static Vector2F operator-(Vector2F v, float s)
{
return(Vector2F.Subtract(v, s));
}
/// <summary>
/// Multiplies a vector by a scalar and put the result in another vector.
/// </summary>
/// <param name="vector">A <see cref="Vector2F"/> instance.</param>
/// <param name="scalar">A single-precision floating-point number.</param>
/// <param name="result">A <see cref="Vector2F"/> instance to hold the result.</param>
public static void Multiply(Vector2F vector, float scalar, ref Vector2F result)
{
result.X = vector.X * scalar;
result.Y = vector.Y * scalar;
}
/// <summary>
/// Subtracts a vector from a scalar.
/// </summary>
/// <param name="v">A <see cref="Vector2F"/> instance.</param>
/// <param name="s">A scalar.</param>
/// <returns>A new <see cref="Vector2F"/> instance containing the difference.</returns>
/// <remarks>
/// result[i] = s - v[i]
/// </remarks>
public static Vector2F operator-(float s, Vector2F v)
{
return(Vector2F.Subtract(s, v));
}
/// <summary>
/// Calculates the Kross product of two vectors.
/// </summary>
/// <param name="left">A <see cref="Vector2F"/> instance.</param>
/// <param name="right">A <see cref="Vector2F"/> instance.</param>
/// <returns>The Kross product value.</returns>
/// <remarks>
/// <p>
/// The Kross product is defined as:
/// Kross(u,v) = u.X*v.Y - u.Y*v.X.
/// </p>
/// <p>
/// The operation is related to the cross product in 3D given by (x0, y0, 0) X (x1, y1, 0) = (0, 0, Kross((x0, y0), (x1, y1))).
/// The operation has the property that Kross(u, v) = -Kross(v, u).
/// </p>
/// </remarks>
public static float KrossProduct(Vector2F left, Vector2F right)
{
return (left.X * right.Y) - (left.Y * right.X);
}
/// <summary>
/// Multiplies a vector by a scalar.
/// </summary>
/// <param name="v">A <see cref="Vector2F"/> instance.</param>
/// <param name="s">A scalar.</param>
/// <returns>A new <see cref="Vector2F"/> containing the result.</returns>
public static Vector2F operator*(float s, Vector2F v)
{
return(Vector2F.Multiply(v, s));
}
/// <summary>
/// Tests whether two vectors are approximately equal using default tolerance value.
/// </summary>
/// <param name="left">A <see cref="Vector2F"/> instance.</param>
/// <param name="right">A <see cref="Vector2F"/> instance.</param>
/// <returns><see langword="true"/> if the two vectors are approximately equal; otherwise, <see langword="false"/>.</returns>
public static bool ApproxEqual(Vector2F left, Vector2F right)
{
return ApproxEqual(left, right, MathFunctions.EpsilonF);
}
/// <summary>
/// Divides a vector by a scalar.
/// </summary>
/// <param name="v">A <see cref="Vector2F"/> instance.</param>
/// <param name="s">A scalar</param>
/// <returns>A new <see cref="Vector2F"/> containing the quotient.</returns>
/// <remarks>
/// result[i] = v[i] / s;
/// </remarks>
public static Vector2F operator/(Vector2F v, float s)
{
return(Vector2F.Divide(v, s));
}
/// <summary>
/// Initializes a new instance of the <see cref="Vector2F"/> class using coordinates from a given <see cref="Vector2F"/> instance.
/// </summary>
/// <param name="vector">A <see cref="Vector2F"/> to get the coordinates from.</param>
public Vector2F(Vector2F vector)
{
_x = vector.X;
_y = vector.Y;
}
/// <summary>
/// Divides a scalar by a vector.
/// </summary>
/// <param name="v">A <see cref="Vector2F"/> instance.</param>
/// <param name="s">A scalar</param>
/// <returns>A new <see cref="Vector2F"/> containing the quotient.</returns>
/// <remarks>
/// result[i] = s / v[i]
/// </remarks>
public static Vector2F operator/(float s, Vector2F v)
{
return(Vector2F.Divide(s, v));
}
/// <summary>
/// Initializes a new instance of the <see cref="Vector2F"/> class using coordinates from a given <see cref="Vector2F"/> instance.
/// </summary>
/// <param name="vector">A <see cref="Vector2F"/> to get the coordinates from.</param>
public Vector2F(Vector2F vector)
{
_x = vector.X;
_y = vector.Y;
}
/// <summary>
/// Transforms a given vector by a matrix.
/// </summary>
/// <param name="matrix">A <see cref="Matrix2F"/> instance.</param>
/// <param name="vector">A <see cref="Vector2F"/> instance.</param>
/// <returns>A new <see cref="Vector2F"/> instance containing the result.</returns>
public static Vector2F Transform(Matrix2F matrix, Vector2F vector)
{
return(new Vector2F(
(matrix.M11 * vector.X) + (matrix.M12 * vector.Y),
(matrix.M21 * vector.X) + (matrix.M22 * vector.Y)));
}
/// <summary>
/// Initializes a new instance of the <see cref="OrientedBox"/> class using given values from another box instance.
/// </summary>
/// <param name="box">A <see cref="OrientedBox"/> instance to take values from.</param>
public OrientedBox(OrientedBox box)
{
_center = box.Center;
_axis1 = box.Axis1;
_axis2 = box.Axis2;
_extent1 = box.Extent1;
_extent2 = box.Extent2;
}
/// <summary>
/// Transforms a given vector by a matrix and put the result in a vector.
/// </summary>
/// <param name="matrix">A <see cref="Matrix2F"/> instance.</param>
/// <param name="vector">A <see cref="Vector2F"/> instance.</param>
/// <param name="result">A <see cref="Vector2F"/> instance to hold the result.</param>
public static void Transform(Matrix2F matrix, Vector2F vector, ref Vector2F result)
{
result.X = (matrix.M11 * vector.X) + (matrix.M12 * vector.Y);
result.Y = (matrix.M21 * vector.X) + (matrix.M22 * vector.Y);
}
/// <summary>
/// Initializes a new instance of the <see cref="Circle"/> class using values from another circle instance.
/// </summary>
/// <param name="circle">A <see cref="Circle"/> instance to take values from.</param>
public Circle(Circle circle)
{
_c = circle._c;
_r = circle._r;
}
/// <summary>
/// Initializes a new instance of the <see cref="Matrix2F"/> structure with the specified values.
/// </summary>
/// <param name="column1">A <see cref="Vector2F"/> instance holding values for the first column.</param>
/// <param name="column2">A <see cref="Vector2F"/> instance holding values for the second column.</param>
public Matrix2F(Vector2F column1, Vector2F column2)
{
_m11 = column1.X; _m12 = column2.X;
_m21 = column1.Y; _m22 = column2.Y;
}
/// <summary>
/// Transforms a given vector by a matrix.
/// </summary>
/// <param name="matrix">A <see cref="Matrix2F"/> instance.</param>
/// <param name="vector">A <see cref="Vector2F"/> instance.</param>
/// <returns>A new <see cref="Vector2F"/> instance containing the result.</returns>
public static Vector2F Transform(Matrix2F matrix, Vector2F vector)
{
return new Vector2F(
(matrix.M11 * vector.X) + (matrix.M12 * vector.Y),
(matrix.M21 * vector.X) + (matrix.M22 * vector.Y));
}
/// <summary>
/// Subtracts a vector from a vector.
/// </summary>
/// <param name="left">A <see cref="Vector2F"/> instance.</param>
/// <param name="right">A <see cref="Vector2F"/> instance.</param>
/// <returns>A new <see cref="Vector2F"/> instance containing the difference.</returns>
/// <remarks>
/// result[i] = left[i] - right[i].
/// </remarks>
public static Vector2F Subtract(Vector2F left, Vector2F right)
{
return new Vector2F(left.X - right.X, left.Y - right.Y);
}
/// <summary>
/// Initializes a new instance of the <see cref="Matrix2F"/> structure with the specified values.
/// </summary>
/// <param name="column1">A <see cref="Vector2F"/> instance holding values for the first column.</param>
/// <param name="column2">A <see cref="Vector2F"/> instance holding values for the second column.</param>
public Matrix2F(Vector2F column1, Vector2F column2)
{
_m11 = column1.X; _m12 = column2.X;
_m21 = column1.Y; _m22 = column2.Y;
}
/// <summary>
/// Subtracts a scalar from a vector.
/// </summary>
/// <param name="v">A <see cref="Vector2F"/> instance.</param>
/// <param name="s">A scalar.</param>
/// <returns>A new <see cref="Vector2F"/> instance containing the difference.</returns>
/// <remarks>
/// result[i] = v[i] - s
/// </remarks>
public static Vector2F Subtract(Vector2F v, float s)
{
return(new Vector2F(v.X - s, v.Y - s));
}
