/// <summary>
/// Creates a matrix that uniformally scales along all three axis.
/// </summary>
/// <param name="scale">The uniform scale that is applied along all axis.</param>
/// <param name="result">When the method completes, contains the created scaling matrix.</param>
public static void Scaling(float scale, out Matrix3x2 result)
{
result = Matrix3x2.Identity;
result.M11 = result.M22 = scale;
}
/// <summary>
/// Creates a matrix that is scaling from a specified center.
/// </summary>
/// <param name="x">Scaling factor that is applied along the x-axis.</param>
/// <param name="y">Scaling factor that is applied along the y-axis.</param>
/// <param name="center">The center of the scaling.</param>
/// <param name="result">The created scaling matrix.</param>
public static void Scaling( float x, float y, ref Vector2 center, out Matrix3x2 result)
{
Matrix3x2 localResult;
localResult.M11 = x; localResult.M12 = 0.0f;
localResult.M21 = 0.0f; localResult.M22 = y;
localResult.M31 = center.X - (x * center.X);
localResult.M32 = center.Y - (y * center.Y);
result = localResult;
}
/// <summary>
/// Determines the sum of two matrices.
/// </summary>
/// <param name="left">The first matrix to add.</param>
/// <param name="right">The second matrix to add.</param>
/// <returns>The sum of the two matrices.</returns>
public static Matrix3x2 Add(Matrix3x2 left, Matrix3x2 right)
{
Matrix3x2 result;
Add(ref left, ref right, out result);
return result;
}
/// <summary>
/// Creates a matrix that scales along the x-axis, y-axis, and y-axis.
/// </summary>
/// <param name="x">Scaling factor that is applied along the x-axis.</param>
/// <param name="y">Scaling factor that is applied along the y-axis.</param>
/// <param name="result">When the method completes, contains the created scaling matrix.</param>
public static void Scaling(float x, float y, out Matrix3x2 result)
{
result = Matrix3x2.Identity;
result.M11 = x;
result.M22 = y;
}
/// <summary>
/// Transforms a vector by this matrix.
/// </summary>
/// <param name="matrix">The matrix to use as a tranformation matrix.</param>
/// <param name="point">The original vector to apply the transformation.</param>
/// <param name="result">The result of the transformation for the input vector.</param>
/// <returns></returns>
public static void TransformPoint(ref Matrix3x2 matrix, ref Vector2 point, out Vector2 result)
{
Vector2 localResult;
localResult.X = (point.X * matrix.M11) + (point.Y * matrix.M21) + matrix.M31;
localResult.Y = (point.X * matrix.M12) + (point.Y * matrix.M22) + matrix.M32;
result = localResult;
}
/// <summary>
/// Calculates the inverse of the specified matrix.
/// </summary>
/// <param name="value">The matrix whose inverse is to be calculated.</param>
/// <param name="result">When the method completes, contains the inverse of the specified matrix.</param>
public static void Invert(ref Matrix3x2 value, out Matrix3x2 result)
{
float determinant = value.Determinant();
if (MathUtil.WithinEpsilon(determinant, 0.0f))
{
result = Identity;
return;
}
float invdet = 1.0f / determinant;
float _offsetX = value.M31;
float _offsetY = value.M32;
result = new Matrix3x2(
value.M22 * invdet,
-value.M12 * invdet,
-value.M21 * invdet,
value.M11 * invdet,
(value.M21 * _offsetY - _offsetX * value.M22) * invdet,
(_offsetX * value.M12 - value.M11 * _offsetY) * invdet);
}
/// <summary>
/// Scales a matrix by the given value.
/// </summary>
/// <param name="left">The matrix to scale.</param>
/// <param name="right">The amount by which to scale.</param>
/// <param name="result">When the method completes, contains the scaled matrix.</param>
public static void Divide(ref Matrix3x2 left, float right, out Matrix3x2 result)
{
float inv = 1.0f / right;
result.M11 = left.M11 * inv;
result.M12 = left.M12 * inv;
result.M21 = left.M21 * inv;
result.M22 = left.M22 * inv;
result.M31 = left.M31 * inv;
result.M32 = left.M32 * inv;
}
/// <summary>
/// Creates a translation matrix using the specified offsets.
/// </summary>
/// <param name="x">X-coordinate offset.</param>
/// <param name="y">Y-coordinate offset.</param>
/// <param name="z">Z-coordinate offset.</param>
/// <param name="result">When the method completes, contains the created translation matrix.</param>
public static void Translation(float x, float y, out Matrix3x2 result)
{
result = Matrix3x2.Identity;
result.M31 = x;
result.M32 = y;
}
/// <summary>
/// Determines the product of two matrices.
/// </summary>
/// <param name="left">The first matrix to multiply.</param>
/// <param name="right">The second matrix to multiply.</param>
/// <param name="result">The product of the two matrices.</param>
public static void Multiply(ref Matrix3x2 left, ref Matrix3x2 right, out Matrix3x2 result)
{
result = new Matrix3x2();
result.M11 = (left.M11 * right.M11) + (left.M12 * right.M21);
result.M12 = (left.M11 * right.M12) + (left.M12 * right.M22);
result.M21 = (left.M21 * right.M11) + (left.M22 * right.M21);
result.M22 = (left.M21 * right.M12) + (left.M22 * right.M22);
result.M31 = (left.M31 * right.M11) + (left.M32 * right.M21) + right.M31;
result.M32 = (left.M31 * right.M12) + (left.M32 * right.M22) + right.M32;
}
/// <summary>
/// Determines the product of two matrices.
/// </summary>
/// <param name="left">The first matrix to multiply.</param>
/// <param name="right">The second matrix to multiply.</param>
/// <returns>The product of the two matrices.</returns>
public static Matrix3x2 Multiply(Matrix3x2 left, Matrix3x2 right)
{
Matrix3x2 result;
Multiply(ref left, ref right, out result);
return result;
}
/// <summary>
/// Scales a matrix by the given value.
/// </summary>
/// <param name="left">The matrix to scale.</param>
/// <param name="right">The amount by which to scale.</param>
/// <param name="result">When the method completes, contains the scaled matrix.</param>
public static void Multiply(ref Matrix3x2 left, float right, out Matrix3x2 result)
{
result.M11 = left.M11 * right;
result.M12 = left.M12 * right;
result.M21 = left.M21 * right;
result.M22 = left.M22 * right;
result.M31 = left.M31 * right;
result.M32 = left.M32 * right;
}
/// <summary>
/// Determines the difference between two matrices.
/// </summary>
/// <param name="left">The first matrix to subtract.</param>
/// <param name="right">The second matrix to subtract.</param>
/// <returns>The difference between the two matrices.</returns>
public static Matrix3x2 Subtract(Matrix3x2 left, Matrix3x2 right)
{
Matrix3x2 result;
Subtract(ref left, ref right, out result);
return result;
}
/// <summary>
/// Determines the difference between two matrices.
/// </summary>
/// <param name="left">The first matrix to subtract.</param>
/// <param name="right">The second matrix to subtract.</param>
/// <param name="result">When the method completes, contains the difference between the two matrices.</param>
public static void Subtract(ref Matrix3x2 left, ref Matrix3x2 right, out Matrix3x2 result)
{
result.M11 = left.M11 - right.M11;
result.M12 = left.M12 - right.M12;
result.M21 = left.M21 - right.M21;
result.M22 = left.M22 - right.M22;
result.M31 = left.M31 - right.M31;
result.M32 = left.M32 - right.M32;
}
/// <summary>
/// Creates a matrix that rotates.
/// </summary>
/// <param name="angle">Angle of rotation in radians. Angles are measured clockwise when looking along the rotation axis.</param>
/// <param name="result">When the method completes, contains the created rotation matrix.</param>
public static void Rotation(float angle, out Matrix3x2 result)
{
float cos = (float)Math.Cos(angle);
float sin = (float)Math.Sin(angle);
result = Matrix3x2.Identity;
result.M11 = cos;
result.M12 = sin;
result.M21 = -sin;
result.M22 = cos;
}
/// <summary>
/// Determines the quotient of two matrices.
/// </summary>
/// <param name="left">The first matrix to divide.</param>
/// <param name="right">The second matrix to divide.</param>
/// <param name="result">When the method completes, contains the quotient of the two matrices.</param>
public static void Divide(ref Matrix3x2 left, ref Matrix3x2 right, out Matrix3x2 result)
{
result.M11 = left.M11 / right.M11;
result.M12 = left.M12 / right.M12;
result.M21 = left.M21 / right.M21;
result.M22 = left.M22 / right.M22;
result.M31 = left.M31 / right.M31;
result.M32 = left.M32 / right.M32;
}
/// <summary>
/// Creates a translation matrix using the specified offsets.
/// </summary>
/// <param name="value">The offset for all three coordinate planes.</param>
/// <param name="result">When the method completes, contains the created translation matrix.</param>
public static void Translation(ref Vector2 value, out Matrix3x2 result)
{
Translation(value.X, value.Y, out result);
}
/// <summary>
/// Negates a matrix.
/// </summary>
/// <param name="value">The matrix to be negated.</param>
/// <param name="result">When the method completes, contains the negated matrix.</param>
public static void Negate(ref Matrix3x2 value, out Matrix3x2 result)
{
result.M11 = -value.M11;
result.M12 = -value.M12;
result.M21 = -value.M21;
result.M22 = -value.M22;
result.M31 = -value.M31;
result.M32 = -value.M32;
}
/// <summary>
/// Transforms a vector by this matrix.
/// </summary>
/// <param name="matrix">The matrix to use as a tranformation matrix.</param>
/// <param name="point">The original vector to apply the transformation.</param>
/// <returns>The result of the transformation for the input vector.</returns>
public static Vector2 TransformPoint(Matrix3x2 matrix, Vector2 point)
{
Vector2 result;
result.X = (point.X * matrix.M11) + (point.Y * matrix.M21) + matrix.M31;
result.Y = (point.X * matrix.M12) + (point.Y * matrix.M22) + matrix.M32;
return result;
}
/// <summary>
/// Negates a matrix.
/// </summary>
/// <param name="value">The matrix to be negated.</param>
/// <returns>The negated matrix.</returns>
public static Matrix3x2 Negate(Matrix3x2 value)
{
Matrix3x2 result;
Negate(ref value, out result);
return result;
}
/// <summary>
/// Calculates the inverse of the specified matrix.
/// </summary>
/// <param name="value">The matrix whose inverse is to be calculated.</param>
/// <returns>the inverse of the specified matrix.</returns>
public static Matrix3x2 Invert(Matrix3x2 value)
{
Matrix3x2 result;
Invert(ref value, out result);
return result;
}
/// <summary>
/// Creates a matrix that scales along the x-axis, y-axis, and y-axis.
/// </summary>
/// <param name="scale">Scaling factor for all three axes.</param>
/// <param name="result">When the method completes, contains the created scaling matrix.</param>
public static void Scaling(ref Vector2 scale, out Matrix3x2 result)
{
Scaling(scale.X, scale.Y, out result);
}
/// <summary>
/// Determines whether the specified <see cref="SharpDX.Matrix3x2"/> is equal to this instance.
/// </summary>
/// <param name="other">The <see cref="SharpDX.Matrix3x2"/> to compare with this instance.</param>
/// <returns>
/// <c>true</c> if the specified <see cref="SharpDX.Matrix3x2"/> is equal to this instance; otherwise, <c>false</c>.
/// </returns>
public bool Equals(Matrix3x2 other)
{
return (Math.Abs(other.M11 - M11) < MathUtil.ZeroTolerance &&
Math.Abs(other.M12 - M12) < MathUtil.ZeroTolerance &&
Math.Abs(other.M21 - M21) < MathUtil.ZeroTolerance &&
Math.Abs(other.M22 - M22) < MathUtil.ZeroTolerance &&
Math.Abs(other.M31 - M31) < MathUtil.ZeroTolerance &&
Math.Abs(other.M32 - M32) < MathUtil.ZeroTolerance);
}
/// <summary>
/// Determines the sum of two matrices.
/// </summary>
/// <param name="left">The first matrix to add.</param>
/// <param name="right">The second matrix to add.</param>
/// <param name="result">When the method completes, contains the sum of the two matrices.</param>
public static void Add(ref Matrix3x2 left, ref Matrix3x2 right, out Matrix3x2 result)
{
result.M11 = left.M11 + right.M11;
result.M12 = left.M12 + right.M12;
result.M21 = left.M21 + right.M21;
result.M22 = left.M22 + right.M22;
result.M31 = left.M31 + right.M31;
result.M32 = left.M32 + right.M32;
}
