/// <summary>Attempts to invert the given matrix. If the operation succeeds, the inverted matrix is stored in the result parameter.</summary>
/// <param name="matrix">The source matrix.</param>
/// <param name="result">The output matrix.</param>
/// <returns>True if the operation succeeded, False otherwise.</returns>
public static bool Invert <T>(Matrix3X2 <T> matrix, out Matrix3X2 <T> result)
where T : unmanaged, IFormattable, IEquatable <T>, IComparable <T>
{
T det = Scalar.Subtract(Scalar.Multiply(matrix.M11, matrix.M22), Scalar.Multiply(matrix.M21, matrix.M12));
if (!Scalar.GreaterThanOrEqual(Scalar.Abs(det), Scalar <T> .Epsilon))
{
result = new(Scalar <T> .NaN, Scalar <T> .NaN, Scalar <T> .NaN, Scalar <T> .NaN, Scalar <T> .NaN, Scalar <T> .NaN);
return(false);
}
T invDet = Scalar.Reciprocal(det);
result = default;
result.M11 = Scalar.Multiply(matrix.M22, invDet);
result.M12 = Scalar.Negate(Scalar.Multiply(matrix.M12, invDet));
result.M21 = Scalar.Negate(Scalar.Multiply(matrix.M21, invDet));
result.M22 = Scalar.Multiply(matrix.M11, invDet);
result.M31 = Scalar.Multiply(Scalar.Subtract(Scalar.Multiply(matrix.M21, matrix.M32), Scalar.Multiply(matrix.M31, matrix.M22)), invDet);
result.M32 = Scalar.Multiply(Scalar.Subtract(Scalar.Multiply(matrix.M31, matrix.M12), Scalar.Multiply(matrix.M11, matrix.M32)), invDet);
return(true);
}
/// <summary>
/// Calculates whether this rectangle contains a point.
/// </summary>
/// <param name="point">The point.</param>
/// <returns>True if this rectangle contains the point; False otherwise.</returns>
/// <remarks>This does consider a point on the edge contained.</remarks>
public bool Contains(Vector2D <T> point)
{
var max = Max;
return(Scalar.GreaterThanOrEqual(point.X, Origin.X) && Scalar.GreaterThanOrEqual
(point.Y, Origin.Y) && Scalar.LessThanOrEqual(point.X, max.X) && Scalar.LessThanOrEqual(point.Y, max.Y));
}
/// <summary>
/// Calculates whether this rectangle contains another rectangle
/// </summary>
/// <param name="other">The rectangle.</param>
/// <returns>True if this rectangle contains the given rectangle; False otherwise.</returns>
/// <remarks>This does consider a rectangle that touches the edge contained.</remarks>
public bool Contains(Rectangle <T> other)
{
var tMax = this.Max;
var oMax = other.Max;
return(Scalar.GreaterThanOrEqual(other.Origin.X, this.Origin.X) && Scalar.GreaterThanOrEqual
(other.Origin.Y, this.Origin.Y) && Scalar.LessThanOrEqual(oMax.X, tMax.X) && Scalar.LessThanOrEqual
(oMax.Y, tMax.Y));
}
/// <summary>Creates a spherical billboard that rotates around a specified object position.</summary>
/// <param name="objectPosition">Position of the object the billboard will rotate around.</param>
/// <param name="cameraPosition">Position of the camera.</param>
/// <param name="cameraUpVector">The up vector of the camera.</param>
/// <param name="cameraForwardVector">The forward vector of the camera.</param>
/// <returns>The created billboard matrix</returns>
public static Matrix2X3 <T> CreateBillboard <T>(Vector3D <T> objectPosition, Vector3D <T> cameraPosition, Vector3D <T> cameraUpVector, Vector3D <T> cameraForwardVector)
where T : unmanaged, IFormattable, IEquatable <T>, IComparable <T>
{
Vector3D <T> zaxis = objectPosition - cameraPosition;
var norm = zaxis.LengthSquared;
if (!Scalar.GreaterThanOrEqual(norm, Scalar.As <float, T>(BillboardEpsilon)))
{
zaxis = -cameraForwardVector;
}
else
{
zaxis = Vector3D.Multiply(zaxis, Scalar.Reciprocal(Scalar.Sqrt(norm)));
}
Vector3D <T> xaxis = Vector3D.Normalize(Vector3D.Cross(cameraUpVector, zaxis));
Vector3D <T> yaxis = Vector3D.Cross(zaxis, xaxis);
return(new(xaxis, yaxis));
}
public static Plane <T> Normalize <T>(Plane <T> value)
where T : unmanaged, IFormattable, IEquatable <T>, IComparable <T>
{
/*if (Vector.IsHardwareAccelerated)
* {
* T normalLengthSquared = value.Normal.LengthSquared();
* if (MathF.Abs(normalLengthSquared - 1.0f) < NormalizeEpsilon)
* {
* // It already normalized, so we don't need to farther process.
* return value;
* }
* T normalLength = MathF.Sqrt(normalLengthSquared);
* return new Plane(
* value.Normal / normalLength,
* value.D / normalLength);
* }
* else*/
{
T f = Scalar.Add(
Scalar.Add(Scalar.Multiply(value.Normal.X, value.Normal.X),
Scalar.Multiply(value.Normal.Y, value.Normal.Y)),
Scalar.Multiply(value.Normal.Z, value.Normal.Z));
if (!Scalar.GreaterThanOrEqual(Scalar.Abs(Scalar.Subtract(f, Scalar <T> .One)), Scalar.As <float, T>(NormalizeEpsilon)))
{
return(value); // It already normalized, so we don't need to further process.
}
T fInv = Scalar.Reciprocal(Scalar.Sqrt(f));
return(new(
Scalar.Multiply(value.Normal.X, fInv),
Scalar.Multiply(value.Normal.Y, fInv),
Scalar.Multiply(value.Normal.Z, fInv),
Scalar.Multiply(value.Distance, fInv)));
}
}
/// <summary> /// Calculates whether this box contains another box /// </summary> /// <param name="other">The box.</param> /// <returns>True if this box contains the given box; False otherwise.</returns> /// <remarks>This does consider a box that touches the edge contained.</remarks> public bool Contains(Box2D <T> other) => Scalar.GreaterThanOrEqual(other.Min.X, Min.X) && Scalar.GreaterThanOrEqual(other.Min.Y, Min.Y) && Scalar.LessThanOrEqual(other.Max.X, Max.X) && Scalar.LessThanOrEqual(other.Max.Y, Max.Y);
/// <summary> /// Calculates whether this box contains a point. /// </summary> /// <param name="point">The point.</param> /// <returns>True if this box contains the point; False otherwise.</returns> /// <remarks>This does consider a point on the edge contained.</remarks> public bool Contains(Vector2D <T> point) => Scalar.GreaterThanOrEqual(point.X, Min.X) && Scalar.GreaterThanOrEqual(point.Y, Min.Y) && Scalar.LessThanOrEqual(point.X, Max.X) && Scalar.LessThanOrEqual(point.Y, Max.Y);
/// <summary>Creates a rotation matrix using the given rotation in radians.</summary>
/// <param name="radians">The amount of rotation, in radians.</param>
/// <returns>A rotation matrix.</returns>
public static Matrix3X2 <T> CreateRotation <T>(T radians)
where T : unmanaged, IFormattable, IEquatable <T>, IComparable <T>
{
radians = Scalar.IEEERemainder(radians, Scalar <T> .Tau);
T c, s;
if (Scalar.GreaterThan(radians, Scalar.As <float, T>(-RotationEpsilon)) && !Scalar.GreaterThanOrEqual(radians, Scalar.As <float, T>(RotationEpsilon)))
{
// Exact case for zero rotation.
c = Scalar <T> .One;
s = Scalar <T> .Zero;
}
else if (Scalar.GreaterThan(radians, Scalar.As <float, T>(
#if MATHF
MathF.PI
#else
((float)Math.PI)
#endif
/ 2 - RotationEpsilon)) && !Scalar.GreaterThanOrEqual(radians, Scalar.As <float, T>(
#if MATHF
MathF.PI
#else
((float)Math.PI)
#endif
/ 2 + RotationEpsilon)))
{
// Exact case for 90 degree rotation.
c = Scalar <T> .Zero;
s = Scalar <T> .One;
}
else if (!Scalar.GreaterThanOrEqual(radians, Scalar.As <float, T>(-
#if MATHF
MathF.PI
#else
((float)Math.PI)
#endif
+ RotationEpsilon)) || Scalar.GreaterThan(radians, Scalar.As <float, T>(
#if MATHF
MathF.PI
#else
((float)Math.PI)
#endif
- RotationEpsilon)))
{
// Exact case for 180 degree rotation.
c = Scalar <T> .MinusOne;
s = Scalar <T> .Zero;
}
else if (Scalar.GreaterThan(radians, Scalar.As <float, T>(-
#if MATHF
MathF.PI
#else
((float)Math.PI)
#endif
/ 2 - RotationEpsilon)) && !Scalar.GreaterThanOrEqual(radians, Scalar.As <float, T>(-
#if MATHF
MathF.PI
#else
((float)Math.PI)
#endif
/ 2 + RotationEpsilon)))
{
// Exact case for 270 degree rotation.
c = Scalar <T> .Zero;
s = Scalar <T> .MinusOne;
}
else
{
// Arbitrary rotation.
c = Scalar.Cos(radians);
s = Scalar.Sin(radians);
}
// [ c s ]
// [ -s c ]
// [ 0 0 ]
Matrix3X2 <T> result = Matrix3X2 <T> .Identity;
result.M11 = c;
result.M12 = s;
result.M21 = Scalar.Negate(s);
result.M22 = c;
return(result);
}
/// <summary>Creates a rotation matrix using the given rotation in radians and a center point.</summary>
/// <param name="radians">The amount of rotation, in radians.</param>
/// <param name="centerPoint">The center point.</param>
/// <returns>A rotation matrix.</returns>
public static Matrix3X2 <T> CreateRotation <T>(T radians, Vector2D <T> centerPoint)
where T : unmanaged, IFormattable, IEquatable <T>, IComparable <T>
{
radians = Scalar.IEEERemainder(radians, Scalar <T> .Tau);
T c, s;
if (Scalar.GreaterThan(radians, Scalar.As <float, T>(-RotationEpsilon)) && !Scalar.GreaterThanOrEqual(radians, Scalar.As <float, T>(RotationEpsilon)))
{
// Exact case for zero rotation.
c = Scalar <T> .One;
s = Scalar <T> .Zero;
}
else if (Scalar.GreaterThan(radians, Scalar.As <float, T>(
#if MATHF
MathF.PI
#else
((float)Math.PI)
#endif
/ 2 - RotationEpsilon)) && !Scalar.GreaterThanOrEqual(radians, Scalar.As <float, T>(
#if MATHF
MathF.PI
#else
((float)Math.PI)
#endif
/ 2 + RotationEpsilon)))
{
// Exact case for 90 degree rotation.
c = Scalar <T> .Zero;
s = Scalar <T> .One;
}
else if (!Scalar.GreaterThanOrEqual(radians, Scalar.As <float, T>(-
#if MATHF
MathF.PI
#else
((float)Math.PI)
#endif
+ RotationEpsilon)) || Scalar.GreaterThan(radians, Scalar.As <float, T>(
#if MATHF
MathF.PI
#else
((float)Math.PI)
#endif
- RotationEpsilon)))
{
// Exact case for 180 degree rotation.
c = Scalar <T> .MinusOne;
s = Scalar <T> .Zero;
}
else if (Scalar.GreaterThan(radians, Scalar.As <float, T>(-
#if MATHF
MathF.PI
#else
((float)Math.PI)
#endif
/ 2 - RotationEpsilon)) && !Scalar.GreaterThanOrEqual(radians, Scalar.As <float, T>(-
#if MATHF
MathF.PI
#else
((float)Math.PI)
#endif
/ 2 + RotationEpsilon)))
{
// Exact case for 270 degree rotation.
c = Scalar <T> .Zero;
s = Scalar <T> .MinusOne;
}
else
{
// Arbitrary rotation.
c = Scalar.Cos(radians);
s = Scalar.Sin(radians);
}
T x = Scalar.Add(Scalar.Multiply(centerPoint.X, Scalar.Subtract(Scalar <T> .One, c)), Scalar.Multiply(centerPoint.Y, s));
T y = Scalar.Subtract(Scalar.Multiply(centerPoint.Y, Scalar.Subtract(Scalar <T> .One, c)), Scalar.Multiply(centerPoint.X, s));
// [ c s ]
// [ -s c ]
// [ x y ]
return(new(
new(c, s),
new(Scalar.Negate(s), c),
new(x, y)));
}
/// <summary> /// Calculates whether this box contains another box /// </summary> /// <param name="other">The box.</param> /// <returns>True if this box contains the given box; False otherwise.</returns> /// <remarks>This does consider a box that touches the edge contained.</remarks> public bool Contains(Box3D <T> other) => Scalar.GreaterThanOrEqual(other.Min.X, this.Min.X) && Scalar.GreaterThanOrEqual(other.Min.Y, this.Min.Y) && Scalar.GreaterThanOrEqual(other.Min.Z, this.Min.Z) && Scalar.LessThanOrEqual(other.Max.X, this.Max.X) && Scalar.LessThanOrEqual(other.Max.Y, this.Max.Y) && Scalar.LessThanOrEqual(other.Max.Z, this.Max.Z);
/// <summary>Attempts to extract the scale, translation, and rotation components from the given scale/rotation/translation matrix.
/// If successful, the out parameters will contained the extracted values.</summary>
/// <param name="matrix">The source matrix.</param>
/// <param name="scale">The scaling component of the transformation matrix.</param>
/// <param name="rotation">The rotation component of the transformation matrix.</param>
/// <returns>True if the source matrix was successfully decomposed; False otherwise.</returns>
public static bool Decompose <T>(Matrix3X3 <T> matrix, out Vector3D <T> scale, out Quaternion <T> rotation)
where T : unmanaged, IFormattable, IEquatable <T>, IComparable <T>
{
bool result = true;
unsafe
{
fixed(Vector3D <T> *scaleBase = &scale)
{
T *pfScales = (T *)scaleBase;
T det;
VectorBasis <T> vectorBasis;
Vector3D <T> ** pVectorBasis = (Vector3D <T> **) & vectorBasis;
Matrix3X3 <T> matTemp = Matrix3X3 <T> .Identity;
CanonicalBasis <T> canonicalBasis = default;
Vector3D <T> * pCanonicalBasis = &canonicalBasis.Row0;
canonicalBasis.Row0 = new Vector3D <T>(Scalar <T> .One, Scalar <T> .Zero, Scalar <T> .Zero);
canonicalBasis.Row1 = new Vector3D <T>(Scalar <T> .Zero, Scalar <T> .One, Scalar <T> .Zero);
canonicalBasis.Row2 = new Vector3D <T>(Scalar <T> .Zero, Scalar <T> .Zero, Scalar <T> .One);
pVectorBasis[0] = &matTemp.Row1;
pVectorBasis[1] = &matTemp.Row2;
pVectorBasis[2] = &matTemp.Row3;
*(pVectorBasis[0]) = new Vector3D <T>(matrix.M11, matrix.M12, matrix.M13);
*(pVectorBasis[1]) = new Vector3D <T>(matrix.M21, matrix.M22, matrix.M23);
*(pVectorBasis[2]) = new Vector3D <T>(matrix.M31, matrix.M32, matrix.M33);
scale.X = pVectorBasis[0]->Length;
scale.Y = pVectorBasis[1]->Length;
scale.Z = pVectorBasis[2]->Length;
uint a, b, c;
#region Ranking
T x = pfScales[0], y = pfScales[1], z = pfScales[2];
if (!Scalar.GreaterThanOrEqual(x, y))
{
if (!Scalar.GreaterThanOrEqual(y, z))
{
a = 2;
b = 1;
c = 0;
}
else
{
a = 1;
if (!Scalar.GreaterThanOrEqual(x, z))
{
b = 2;
c = 0;
}
else
{
b = 0;
c = 2;
}
}
}
else
{
if (!Scalar.GreaterThanOrEqual(x, z))
{
a = 2;
b = 0;
c = 1;
}
else
{
a = 0;
if (!Scalar.GreaterThanOrEqual(y, z))
{
b = 2;
c = 1;
}
else
{
b = 1;
c = 2;
}
}
}
#endregion
if (!Scalar.GreaterThanOrEqual(pfScales[a], Scalar.As <float, T>(DecomposeEpsilon)))
{
*(pVectorBasis[a]) = pCanonicalBasis[a];
}
*pVectorBasis[a] = Vector3D.Normalize(*pVectorBasis[a]);
if (!Scalar.GreaterThanOrEqual(pfScales[b], Scalar.As <float, T>(DecomposeEpsilon)))
{
uint cc;
T fAbsX, fAbsY, fAbsZ;
fAbsX = Scalar.Abs(pVectorBasis[a]->X);
fAbsY = Scalar.Abs(pVectorBasis[a]->Y);
fAbsZ = Scalar.Abs(pVectorBasis[a]->Z);
#region Ranking
if (!Scalar.GreaterThanOrEqual(fAbsX, fAbsY))
{
if (!Scalar.GreaterThanOrEqual(fAbsY, fAbsZ))
{
cc = 0;
}
else
{
if (!Scalar.GreaterThanOrEqual(fAbsX, fAbsZ))
{
cc = 0;
}
else
{
cc = 2;
}
}
}
else
{
if (!Scalar.GreaterThanOrEqual(fAbsX, fAbsZ))
{
cc = 1;
}
else
{
if (!Scalar.GreaterThanOrEqual(fAbsY, fAbsZ))
{
cc = 1;
}
else
{
cc = 2;
}
}
}
#endregion
*pVectorBasis[b] = Vector3D.Cross(*pVectorBasis[a], *(pCanonicalBasis + cc));
}
*pVectorBasis[b] = Vector3D.Normalize(*pVectorBasis[b]);
if (!Scalar.GreaterThanOrEqual(pfScales[c], Scalar.As <float, T>(DecomposeEpsilon)))
{
*pVectorBasis[c] = Vector3D.Cross(*pVectorBasis[a], *pVectorBasis[b]);
}
*pVectorBasis[c] = Vector3D.Normalize(*pVectorBasis[c]);
det = matTemp.GetDeterminant();
// use Kramer's rule to check for handedness of coordinate system
if (!Scalar.GreaterThanOrEqual(det, Scalar <T> .Zero))
{
// switch coordinate system by negating the scale and inverting the basis vector on the x-axis
pfScales[a] = Scalar.Negate(pfScales[a]);
*pVectorBasis[a] = -(*pVectorBasis[a]);
det = Scalar.Negate(det);
}
det = Scalar.Subtract(det, Scalar <T> .One);
det = Scalar.Multiply(det, det);
if (!Scalar.GreaterThanOrEqual(Scalar.As <float, T>(DecomposeEpsilon), det))
{
// Non-SRT matrix encountered
rotation = Quaternion <T> .Identity;
result = false;
}
else
{
// generate the quaternion from the matrix
rotation = Quaternion <T> .CreateFromRotationMatrix(matTemp);
}
}
}
return(result);
}
