/// <summary> /// Creates a MatrixD 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="z">Scaling factor that is applied along the z-axis.</param> /// <param name="result">When the method completes, contains the created scaling MatrixD.</param> public static void Scaling(double x, double y, double z, out MatrixD result) { result = MatrixD.Identity; result.M11 = x; result.M22 = y; result.M33 = z; }
/// <summary> /// Determines the quotient of two matrices. /// </summary> /// <param name="left">The first MatrixD to divide.</param> /// <param name="right">The second MatrixD to divide.</param> /// <returns>The quotient of the two matrices.</returns> public static MatrixD Divide(MatrixD left, MatrixD right) { MatrixD result; Divide(ref left, ref right, out result); return result; }
/// <summary> /// Performs the exponential operation on a MatrixD. /// </summary> /// <param name="value">The MatrixD to perform the operation on.</param> /// <param name="exponent">The exponent to raise the MatrixD to.</param> /// <returns>The exponential MatrixD.</returns> /// <exception cref="System.ArgumentOutOfRangeException">Thrown when the <paramref name="exponent"/> is negative.</exception> public static MatrixD Exponent(MatrixD value, int exponent) { MatrixD result; Exponent(ref value, exponent, out result); return result; }
/// <summary> /// Creates a 3D affine transformation MatrixD. /// </summary> /// <param name="scaling">Scaling factor.</param> /// <param name="rotationCenter">The center of the rotation.</param> /// <param name="rotation">The rotation of the transformation.</param> /// <param name="translation">The translation factor of the transformation.</param> /// <param name="result">When the method completes, contains the created affine transformation MatrixD.</param> public static void AffineTransformation(double scaling, ref Vector3D rotationCenter, ref Quaternion rotation, ref Vector3D translation, out MatrixD result) { result = Scaling(scaling) * Translation(-rotationCenter) * RotationQuaternion(rotation) * Translation(rotationCenter) * Translation(translation); }
/// <summary> /// Scales a MatrixD by the given value. /// </summary> /// <param name="left">The MatrixD to scale.</param> /// <param name="right">The amount by which to scale.</param> /// <param name="result">When the method completes, contains the scaled MatrixD.</param> public static void Divide(ref MatrixD left, double right, out MatrixD result) { double inv = 1.0f / right; result.M11 = left.M11 * inv; result.M12 = left.M12 * inv; result.M13 = left.M13 * inv; result.M14 = left.M14 * inv; result.M21 = left.M21 * inv; result.M22 = left.M22 * inv; result.M23 = left.M23 * inv; result.M24 = left.M24 * inv; result.M31 = left.M31 * inv; result.M32 = left.M32 * inv; result.M33 = left.M33 * inv; result.M34 = left.M34 * inv; result.M41 = left.M41 * inv; result.M42 = left.M42 * inv; result.M43 = left.M43 * inv; result.M44 = left.M44 * inv; }
/// <summary> /// Decomposes a MatrixD into an orthonormalized MatrixD Q and a right triangular MatrixD R. /// </summary> /// <param name="Q">When the method completes, contains the orthonormalized MatrixD of the decomposition.</param> /// <param name="R">When the method completes, contains the right triangular MatrixD of the decomposition.</param> public void DecomposeQR(out MatrixD Q, out MatrixD R) { MatrixD temp = this; temp.Transpose(); Orthonormalize(ref temp, out Q); Q.Transpose(); R = new MatrixD(); R.M11 = Vector4D.Dot(Q.Column1, Column1); R.M12 = Vector4D.Dot(Q.Column1, Column2); R.M13 = Vector4D.Dot(Q.Column1, Column3); R.M14 = Vector4D.Dot(Q.Column1, Column4); R.M22 = Vector4D.Dot(Q.Column2, Column2); R.M23 = Vector4D.Dot(Q.Column2, Column3); R.M24 = Vector4D.Dot(Q.Column2, Column4); R.M33 = Vector4D.Dot(Q.Column3, Column3); R.M34 = Vector4D.Dot(Q.Column3, Column4); R.M44 = Vector4D.Dot(Q.Column4, Column4); }
/// <summary> /// Determines the sum of two matrices. /// </summary> /// <param name="left">The first MatrixD to add.</param> /// <param name="right">The second MatrixD to add.</param> /// <param name="result">When the method completes, contains the sum of the two matrices.</param> public static void Add(ref MatrixD left, ref MatrixD right, out MatrixD result) { result.M11 = left.M11 + right.M11; result.M12 = left.M12 + right.M12; result.M13 = left.M13 + right.M13; result.M14 = left.M14 + right.M14; result.M21 = left.M21 + right.M21; result.M22 = left.M22 + right.M22; result.M23 = left.M23 + right.M23; result.M24 = left.M24 + right.M24; result.M31 = left.M31 + right.M31; result.M32 = left.M32 + right.M32; result.M33 = left.M33 + right.M33; result.M34 = left.M34 + right.M34; result.M41 = left.M41 + right.M41; result.M42 = left.M42 + right.M42; result.M43 = left.M43 + right.M43; result.M44 = left.M44 + right.M44; }
/// <summary> /// Determines the difference between two matrices. /// </summary> /// <param name="left">The first MatrixD to subtract.</param> /// <param name="right">The second MatrixD to subtract.</param> /// <param name="result">When the method completes, contains the difference between the two matrices.</param> public static void Subtract(ref MatrixD left, ref MatrixD right, out MatrixD result) { result.M11 = left.M11 - right.M11; result.M12 = left.M12 - right.M12; result.M13 = left.M13 - right.M13; result.M14 = left.M14 - right.M14; result.M21 = left.M21 - right.M21; result.M22 = left.M22 - right.M22; result.M23 = left.M23 - right.M23; result.M24 = left.M24 - right.M24; result.M31 = left.M31 - right.M31; result.M32 = left.M32 - right.M32; result.M33 = left.M33 - right.M33; result.M34 = left.M34 - right.M34; result.M41 = left.M41 - right.M41; result.M42 = left.M42 - right.M42; result.M43 = left.M43 - right.M43; result.M44 = left.M44 - right.M44; }
/// <summary> /// Determines the difference between two matrices. /// </summary> /// <param name="left">The first MatrixD to subtract.</param> /// <param name="right">The second MatrixD to subtract.</param> /// <returns>The difference between the two matrices.</returns> public static MatrixD Subtract(MatrixD left, MatrixD right) { MatrixD result; Subtract(ref left, ref right, out result); return result; }
/// <summary> /// Performs a cubic interpolation between two matrices. /// </summary> /// <param name="start">Start MatrixD.</param> /// <param name="end">End MatrixD.</param> /// <param name="amount">Value between 0 and 1 indicating the weight of <paramref name="end"/>.</param> /// <param name="result">When the method completes, contains the cubic interpolation of the two matrices.</param> public static void SmoothStep(ref MatrixD start, ref MatrixD end, double amount, out MatrixD result) { amount = MathUtilD.SmoothStep(amount); Lerp(ref start, ref end, amount, out result); }
/// <summary> /// Performs a cubic interpolation between two matrices. /// </summary> /// <param name="start">Start MatrixD.</param> /// <param name="end">End MatrixD.</param> /// <param name="amount">Value between 0 and 1 indicating the weight of <paramref name="end"/>.</param> /// <returns>The cubic interpolation of the two matrices.</returns> public static MatrixD SmoothStep(MatrixD start, MatrixD end, double amount) { MatrixD result; SmoothStep(ref start, ref end, amount, out result); return result; }
/// <summary> /// Creates a skew/shear MatrixD by means of a translation vector, a rotation vector, and a rotation angle. /// shearing is performed in the direction of translation vector, where translation vector and rotation vector define the shearing plane. /// The effect is such that the skewed rotation vector has the specified angle with rotation itself. /// </summary> /// <param name="angle">The rotation angle.</param> /// <param name="rotationVec">The rotation vector</param> /// <param name="transVec">The translation vector</param> /// <param name="MatrixD">Contains the created skew/shear MatrixD. </param> public static void Skew(double angle, ref Vector3D rotationVec, ref Vector3D transVec, out MatrixD MatrixD) { //http://elckerlyc.ewi.utwente.nl/browser/Elckerlyc/Hmi/HmiMath/src/hmi/math/Mat3f.java double MINIMAL_SKEW_ANGLE = 0.000001f; Vector3D e0 = rotationVec; Vector3D e1 = Vector3D.Normalize(transVec); double rv1; Vector3D.Dot(ref rotationVec, ref e1, out rv1); e0 += rv1 * e1; double rv0; Vector3D.Dot(ref rotationVec, ref e0, out rv0); double cosa = (double)System.Math.Cos(angle); double sina = (double)System.Math.Sin(angle); double rr0 = rv0 * cosa - rv1 * sina; double rr1 = rv0 * sina + rv1 * cosa; if (rr0 < MINIMAL_SKEW_ANGLE) throw new ArgumentException("illegal skew angle"); double d = (rr1 / rr0) - (rv1 / rv0); MatrixD = MatrixD.Identity; MatrixD.M11 = d * e1[0] * e0[0] + 1.0f; MatrixD.M12 = d * e1[0] * e0[1]; MatrixD.M13 = d * e1[0] * e0[2]; MatrixD.M21 = d * e1[1] * e0[0]; MatrixD.M22 = d * e1[1] * e0[1] + 1.0f; MatrixD.M23 = d * e1[1] * e0[2]; MatrixD.M31 = d * e1[2] * e0[0]; MatrixD.M32 = d * e1[2] * e0[1]; MatrixD.M33 = d * e1[2] * e0[2] + 1.0f; }
/// <summary> /// Creates a MatrixD that flattens geometry into a shadow. /// </summary> /// <param name="light">The light direction. If the W component is 0, the light is directional light; if the /// W component is 1, the light is a point light.</param> /// <param name="plane">The plane onto which to project the geometry as a shadow. This parameter is assumed to be normalized.</param> /// <param name="result">When the method completes, contains the shadow MatrixD.</param> public static void Shadow(ref Vector4D light, ref Plane plane, out MatrixD result) { double dot = (plane.Normal.X * light.X) + (plane.Normal.Y * light.Y) + (plane.Normal.Z * light.Z) + (plane.D * light.W); double x = -plane.Normal.X; double y = -plane.Normal.Y; double z = -plane.Normal.Z; double d = -plane.D; result.M11 = (x * light.X) + dot; result.M21 = y * light.X; result.M31 = z * light.X; result.M41 = d * light.X; result.M12 = x * light.Y; result.M22 = (y * light.Y) + dot; result.M32 = z * light.Y; result.M42 = d * light.Y; result.M13 = x * light.Z; result.M23 = y * light.Z; result.M33 = (z * light.Z) + dot; result.M43 = d * light.Z; result.M14 = x * light.W; result.M24 = y * light.W; result.M34 = z * light.W; result.M44 = (d * light.W) + dot; }
/// <summary> /// Creates a MatrixD that uniformly 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 MatrixD.</param> public static void Scaling(double scale, out MatrixD result) { result = MatrixD.Identity; result.M11 = result.M22 = result.M33 = scale; }
/// <summary> /// Brings the MatrixD into upper triangular form using elementary row operations. /// </summary> /// <param name="value">The MatrixD to put into upper triangular form.</param> /// <returns>The upper triangular MatrixD.</returns> /// <remarks> /// If the MatrixD is not invertible (i.e. its determinant is zero) than the result of this /// method may produce Single.Nan and Single.Inf values. When the MatrixD represents a system /// of linear equations, than this often means that either no solution exists or an infinite /// number of solutions exist. /// </remarks> public static MatrixD UpperTriangularForm(MatrixD value) { MatrixD result; UpperTriangularForm(ref value, out result); return result; }
/// <summary> /// Creates a transformation MatrixD. /// </summary> /// <param name="scalingCenter">Center point of the scaling operation.</param> /// <param name="scalingRotation">Scaling rotation amount.</param> /// <param name="scaling">Scaling factor.</param> /// <param name="rotationCenter">The center of the rotation.</param> /// <param name="rotation">The rotation of the transformation.</param> /// <param name="translation">The translation factor of the transformation.</param> /// <param name="result">When the method completes, contains the created transformation MatrixD.</param> public static void Transformation(ref Vector3D scalingCenter, ref Quaternion scalingRotation, ref Vector3D scaling, ref Vector3D rotationCenter, ref Quaternion rotation, ref Vector3D translation, out MatrixD result) { MatrixD sr = RotationQuaternion(scalingRotation); result = Translation(-scalingCenter) * Transpose(sr) * Scaling(scaling) * sr * Translation(scalingCenter) * Translation(-rotationCenter) * RotationQuaternion(rotation) * Translation(rotationCenter) * Translation(translation); }
/// <summary> /// Decomposes a MatrixD into a lower triangular MatrixD L and an orthonormalized MatrixD Q. /// </summary> /// <param name="L">When the method completes, contains the lower triangular MatrixD of the decomposition.</param> /// <param name="Q">When the method completes, contains the orthonormalized MatrixD of the decomposition.</param> public void DecomposeLQ(out MatrixD L, out MatrixD Q) { Orthonormalize(ref this, out Q); L = new MatrixD(); L.M11 = Vector4D.Dot(Q.Row1, Row1); L.M21 = Vector4D.Dot(Q.Row1, Row2); L.M22 = Vector4D.Dot(Q.Row2, Row2); L.M31 = Vector4D.Dot(Q.Row1, Row3); L.M32 = Vector4D.Dot(Q.Row2, Row3); L.M33 = Vector4D.Dot(Q.Row3, Row3); L.M41 = Vector4D.Dot(Q.Row1, Row4); L.M42 = Vector4D.Dot(Q.Row2, Row4); L.M43 = Vector4D.Dot(Q.Row3, Row4); L.M44 = Vector4D.Dot(Q.Row4, Row4); }
/// <summary> /// Creates a translation MatrixD 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 MatrixD.</param> public static void Translation(ref Vector3D value, out MatrixD result) { Translation(value.X, value.Y, value.Z, out result); }
/// <summary> /// Determines whether the specified <see cref="SharpDX.MatrixD"/> is equal to this instance. /// </summary> /// <param name="other">The <see cref="SharpDX.MatrixD"/> to compare with this instance.</param> /// <returns> /// <c>true</c> if the specified <see cref="SharpDX.MatrixD"/> is equal to this instance; otherwise, <c>false</c>. /// </returns> public bool Equals(MatrixD other) { return (MathUtilD.WithinEpsilon(other.M11, M11) && MathUtilD.WithinEpsilon(other.M12, M12) && MathUtilD.WithinEpsilon(other.M13, M13) && MathUtilD.WithinEpsilon(other.M14, M14) && MathUtilD.WithinEpsilon(other.M21, M21) && MathUtilD.WithinEpsilon(other.M22, M22) && MathUtilD.WithinEpsilon(other.M23, M23) && MathUtilD.WithinEpsilon(other.M24, M24) && MathUtilD.WithinEpsilon(other.M31, M31) && MathUtilD.WithinEpsilon(other.M32, M32) && MathUtilD.WithinEpsilon(other.M33, M33) && MathUtilD.WithinEpsilon(other.M34, M34) && MathUtilD.WithinEpsilon(other.M41, M41) && MathUtilD.WithinEpsilon(other.M42, M42) && MathUtilD.WithinEpsilon(other.M43, M43) && MathUtilD.WithinEpsilon(other.M44, M44)); }
/// <summary> /// Creates a translation MatrixD 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 MatrixD.</param> public static void Translation(double x, double y, double z, out MatrixD result) { result = MatrixD.Identity; result.M41 = x; result.M42 = y; result.M43 = z; }
/// <summary> /// Determines the sum of two matrices. /// </summary> /// <param name="left">The first MatrixD to add.</param> /// <param name="right">The second MatrixD to add.</param> /// <returns>The sum of the two matrices.</returns> public static MatrixD Add(MatrixD left, MatrixD right) { MatrixD result; Add(ref left, ref right, out result); return result; }
/// <summary> /// Calculates the transpose of the specified MatrixD. /// </summary> /// <param name="value">The MatrixD whose transpose is to be calculated.</param> /// <param name="result">When the method completes, contains the transpose of the specified MatrixD.</param> public static void Transpose(ref MatrixD value, out MatrixD result) { MatrixD temp = new MatrixD(); temp.M11 = value.M11; temp.M12 = value.M21; temp.M13 = value.M31; temp.M14 = value.M41; temp.M21 = value.M12; temp.M22 = value.M22; temp.M23 = value.M32; temp.M24 = value.M42; temp.M31 = value.M13; temp.M32 = value.M23; temp.M33 = value.M33; temp.M34 = value.M43; temp.M41 = value.M14; temp.M42 = value.M24; temp.M43 = value.M34; temp.M44 = value.M44; result = temp; }
/// <summary> /// Creates a spherical billboard that rotates around a specified object position. /// </summary> /// <param name="objectPosition">The position of the object around which the billboard will rotate.</param> /// <param name="cameraPosition">The 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> /// <param name="result">When the method completes, contains the created billboard MatrixD.</param> public static void Billboard(ref Vector3D objectPosition, ref Vector3D cameraPosition, ref Vector3D cameraUpVector, ref Vector3D cameraForwardVector, out MatrixD result) { Vector3D crossed; Vector3D final; Vector3D difference = objectPosition - cameraPosition; double lengthSq = difference.LengthSquared(); if (MathUtilD.IsZero(lengthSq)) difference = -cameraForwardVector; else difference *= (double)(1.0 / System.Math.Sqrt(lengthSq)); Vector3D.Cross(ref cameraUpVector, ref difference, out crossed); crossed.Normalize(); Vector3D.Cross(ref difference, ref crossed, out final); result.M11 = crossed.X; result.M12 = crossed.Y; result.M13 = crossed.Z; result.M14 = 0.0d; result.M21 = final.X; result.M22 = final.Y; result.M23 = final.Z; result.M24 = 0.0d; result.M31 = difference.X; result.M32 = difference.Y; result.M33 = difference.Z; result.M34 = 0.0d; result.M41 = objectPosition.X; result.M42 = objectPosition.Y; result.M43 = objectPosition.Z; result.M44 = 1.0d; }
/// <summary> /// Calculates the transpose of the specified MatrixD. /// </summary> /// <param name="value">The MatrixD whose transpose is to be calculated.</param> /// <returns>The transpose of the specified MatrixD.</returns> public static MatrixD Transpose(MatrixD value) { MatrixD result; Transpose(ref value, out result); return result; }
/// <summary> /// Determines the quotient of two matrices. /// </summary> /// <param name="left">The first MatrixD to divide.</param> /// <param name="right">The second MatrixD to divide.</param> /// <param name="result">When the method completes, contains the quotient of the two matrices.</param> public static void Divide(ref MatrixD left, ref MatrixD right, out MatrixD result) { result.M11 = left.M11 / right.M11; result.M12 = left.M12 / right.M12; result.M13 = left.M13 / right.M13; result.M14 = left.M14 / right.M14; result.M21 = left.M21 / right.M21; result.M22 = left.M22 / right.M22; result.M23 = left.M23 / right.M23; result.M24 = left.M24 / right.M24; result.M31 = left.M31 / right.M31; result.M32 = left.M32 / right.M32; result.M33 = left.M33 / right.M33; result.M34 = left.M34 / right.M34; result.M41 = left.M41 / right.M41; result.M42 = left.M42 / right.M42; result.M43 = left.M43 / right.M43; result.M44 = left.M44 / right.M44; }
/// <summary> /// Calculates the transpose of the specified MatrixD. /// </summary> /// <param name="value">The MatrixD whose transpose is to be calculated.</param> /// <param name="result">When the method completes, contains the transpose of the specified MatrixD.</param> public static void TransposeByRef(ref MatrixD value, ref MatrixD result) { result.M11 = value.M11; result.M12 = value.M21; result.M13 = value.M31; result.M14 = value.M41; result.M21 = value.M12; result.M22 = value.M22; result.M23 = value.M32; result.M24 = value.M42; result.M31 = value.M13; result.M32 = value.M23; result.M33 = value.M33; result.M34 = value.M43; result.M41 = value.M14; result.M42 = value.M24; result.M43 = value.M34; result.M44 = value.M44; }
/// <summary> /// Performs the exponential operation on a MatrixD. /// </summary> /// <param name="value">The MatrixD to perform the operation on.</param> /// <param name="exponent">The exponent to raise the MatrixD to.</param> /// <param name="result">When the method completes, contains the exponential MatrixD.</param> /// <exception cref="System.ArgumentOutOfRangeException">Thrown when the <paramref name="exponent"/> is negative.</exception> public static void Exponent(ref MatrixD value, int exponent, out MatrixD result) { //Source: http://rosettacode.org //Reference: http://rosettacode.org/wiki/MatrixD-exponentiation_operator if (exponent < 0) throw new ArgumentOutOfRangeException("exponent", "The exponent can not be negative."); if (exponent == 0) { result = MatrixD.Identity; return; } if (exponent == 1) { result = value; return; } MatrixD identity = MatrixD.Identity; MatrixD temp = value; while (true) { if ((exponent & 1) != 0) identity = identity * temp; exponent /= 2; if (exponent > 0) temp *= temp; else break; } result = identity; }
/// <summary> /// Brings the MatrixD into upper triangular form using elementary row operations. /// </summary> /// <param name="value">The MatrixD to put into upper triangular form.</param> /// <param name="result">When the method completes, contains the upper triangular MatrixD.</param> /// <remarks> /// If the MatrixD is not invertible (i.e. its determinant is zero) than the result of this /// method may produce Single.Nan and Single.Inf values. When the MatrixD represents a system /// of linear equations, than this often means that either no solution exists or an infinite /// number of solutions exist. /// </remarks> public static void UpperTriangularForm(ref MatrixD value, out MatrixD result) { //Adapted from the row echelon code. result = value; int lead = 0; int rowcount = 4; int columncount = 4; for (int r = 0; r < rowcount; ++r) { if (columncount <= lead) return; int i = r; while (MathUtilD.IsZero(result[i, lead])) { i++; if (i == rowcount) { i = r; lead++; if (lead == columncount) return; } } if (i != r) { result.ExchangeRows(i, r); } double multiplier = 1d / result[r, lead]; for (; i < rowcount; ++i) { if (i != r) { result[i, 0] -= result[r, 0] * multiplier * result[i, lead]; result[i, 1] -= result[r, 1] * multiplier * result[i, lead]; result[i, 2] -= result[r, 2] * multiplier * result[i, lead]; result[i, 3] -= result[r, 3] * multiplier * result[i, lead]; } } lead++; } }
/// <summary> /// Calculates the inverse of the specified MatrixD. /// </summary> /// <param name="value">The MatrixD whose inverse is to be calculated.</param> /// <param name="result">When the method completes, contains the inverse of the specified MatrixD.</param> public static void Invert(ref MatrixD value, out MatrixD result) { double b0 = (value.M31 * value.M42) - (value.M32 * value.M41); double b1 = (value.M31 * value.M43) - (value.M33 * value.M41); double b2 = (value.M34 * value.M41) - (value.M31 * value.M44); double b3 = (value.M32 * value.M43) - (value.M33 * value.M42); double b4 = (value.M34 * value.M42) - (value.M32 * value.M44); double b5 = (value.M33 * value.M44) - (value.M34 * value.M43); double d11 = value.M22 * b5 + value.M23 * b4 + value.M24 * b3; double d12 = value.M21 * b5 + value.M23 * b2 + value.M24 * b1; double d13 = value.M21 * -b4 + value.M22 * b2 + value.M24 * b0; double d14 = value.M21 * b3 + value.M22 * -b1 + value.M23 * b0; double det = value.M11 * d11 - value.M12 * d12 + value.M13 * d13 - value.M14 * d14; if (System.Math.Abs(det) == 0.0f) { result = MatrixD.Zero; return; } det = 1f / det; double a0 = (value.M11 * value.M22) - (value.M12 * value.M21); double a1 = (value.M11 * value.M23) - (value.M13 * value.M21); double a2 = (value.M14 * value.M21) - (value.M11 * value.M24); double a3 = (value.M12 * value.M23) - (value.M13 * value.M22); double a4 = (value.M14 * value.M22) - (value.M12 * value.M24); double a5 = (value.M13 * value.M24) - (value.M14 * value.M23); double d21 = value.M12 * b5 + value.M13 * b4 + value.M14 * b3; double d22 = value.M11 * b5 + value.M13 * b2 + value.M14 * b1; double d23 = value.M11 * -b4 + value.M12 * b2 + value.M14 * b0; double d24 = value.M11 * b3 + value.M12 * -b1 + value.M13 * b0; double d31 = value.M42 * a5 + value.M43 * a4 + value.M44 * a3; double d32 = value.M41 * a5 + value.M43 * a2 + value.M44 * a1; double d33 = value.M41 * -a4 + value.M42 * a2 + value.M44 * a0; double d34 = value.M41 * a3 + value.M42 * -a1 + value.M43 * a0; double d41 = value.M32 * a5 + value.M33 * a4 + value.M34 * a3; double d42 = value.M31 * a5 + value.M33 * a2 + value.M34 * a1; double d43 = value.M31 * -a4 + value.M32 * a2 + value.M34 * a0; double d44 = value.M31 * a3 + value.M32 * -a1 + value.M33 * a0; result.M11 = +d11 * det; result.M12 = -d21 * det; result.M13 = +d31 * det; result.M14 = -d41 * det; result.M21 = -d12 * det; result.M22 = +d22 * det; result.M23 = -d32 * det; result.M24 = +d42 * det; result.M31 = +d13 * det; result.M32 = -d23 * det; result.M33 = +d33 * det; result.M34 = -d43 * det; result.M41 = -d14 * det; result.M42 = +d24 * det; result.M43 = -d34 * det; result.M44 = +d44 * det; }
/// <summary> /// Creates a MatrixD 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 MatrixD.</param> public static void Scaling(ref Vector3D scale, out MatrixD result) { Scaling(scale.X, scale.Y, scale.Z, out result); }