Transformation methods

matTransformatiosn.txt

public static Matrix Invert(Matrix matrix)
{
    Matrix matrix2;
    float num5 = matrix.M11;
    float num4 = matrix.M12;
    float num3 = matrix.M13;
    float num2 = matrix.M14;
    float num9 = matrix.M21;
    float num8 = matrix.M22;
    float num7 = matrix.M23;
    float num6 = matrix.M24;
    float num17 = matrix.M31;
    float num16 = matrix.M32;
    float num15 = matrix.M33;
    float num14 = matrix.M34;
    float num13 = matrix.M41;
    float num12 = matrix.M42;
    float num11 = matrix.M43;
    float num10 = matrix.M44;
    float num23 = (num15 * num10) - (num14 * num11);
    float num22 = (num16 * num10) - (num14 * num12);
    float num21 = (num16 * num11) - (num15 * num12);
    float num20 = (num17 * num10) - (num14 * num13);
    float num19 = (num17 * num11) - (num15 * num13);
    float num18 = (num17 * num12) - (num16 * num13);
    float num39 = ((num8 * num23) - (num7 * num22)) + (num6 * num21);
    float num38 = -(((num9 * num23) - (num7 * num20)) + (num6 * num19));
    float num37 = ((num9 * num22) - (num8 * num20)) + (num6 * num18);
    float num36 = -(((num9 * num21) - (num8 * num19)) + (num7 * num18));
    float num = 1f / ((((num5 * num39) + (num4 * num38)) + (num3 * num37)) + (num2 * num36));
    matrix2.M11 = num39 * num;
    matrix2.M21 = num38 * num;
    matrix2.M31 = num37 * num;
    matrix2.M41 = num36 * num;
    matrix2.M12 = -(((num4 * num23) - (num3 * num22)) + (num2 * num21)) * num;
    matrix2.M22 = (((num5 * num23) - (num3 * num20)) + (num2 * num19)) * num;
    matrix2.M32 = -(((num5 * num22) - (num4 * num20)) + (num2 * num18)) * num;
    matrix2.M42 = (((num5 * num21) - (num4 * num19)) + (num3 * num18)) * num;
    float num35 = (num7 * num10) - (num6 * num11);
    float num34 = (num8 * num10) - (num6 * num12);
    float num33 = (num8 * num11) - (num7 * num12);
    float num32 = (num9 * num10) - (num6 * num13);
    float num31 = (num9 * num11) - (num7 * num13);
    float num30 = (num9 * num12) - (num8 * num13);
    matrix2.M13 = (((num4 * num35) - (num3 * num34)) + (num2 * num33)) * num;
    matrix2.M23 = -(((num5 * num35) - (num3 * num32)) + (num2 * num31)) * num;
    matrix2.M33 = (((num5 * num34) - (num4 * num32)) + (num2 * num30)) * num;
    matrix2.M43 = -(((num5 * num33) - (num4 * num31)) + (num3 * num30)) * num;
    float num29 = (num7 * num14) - (num6 * num15);
    float num28 = (num8 * num14) - (num6 * num16);
    float num27 = (num8 * num15) - (num7 * num16);
    float num26 = (num9 * num14) - (num6 * num17);
    float num25 = (num9 * num15) - (num7 * num17);
    float num24 = (num9 * num16) - (num8 * num17);
    matrix2.M14 = -(((num4 * num29) - (num3 * num28)) + (num2 * num27)) * num;
    matrix2.M24 = (((num5 * num29) - (num3 * num26)) + (num2 * num25)) * num;
    matrix2.M34 = -(((num5 * num28) - (num4 * num26)) + (num2 * num24)) * num;
    matrix2.M44 = (((num5 * num27) - (num4 * num25)) + (num3 * num24)) * num;
    return matrix2;
}

 public unsafe bool Decompose(out Vector3 scale, out Quaternion rotation, out Vector3 translation)
{
    bool flag = true;
    fixed (float* numRef = &scale.X)
    {
        uint num;
        uint num3;
        uint num4;
        VectorBasis basis2;
        Vector3** vectorPtr = (Vector3**) &basis2;
        Matrix identity = Identity;
        CanonicalBasis basis = new CanonicalBasis();
        Vector3* vectorPtr2 = &basis.Row0;
        basis.Row0 = new Vector3(1f, 0f, 0f);
        basis.Row1 = new Vector3(0f, 1f, 0f);
        basis.Row2 = new Vector3(0f, 0f, 1f);
        translation.X = this.M41;
        translation.Y = this.M42;
        translation.Z = this.M43;
        *((IntPtr*) vectorPtr) = (IntPtr) &identity.M11;
        *((IntPtr*) (vectorPtr + 1)) = (IntPtr) &identity.M21;
        *((IntPtr*) (vectorPtr + 2)) = (IntPtr) &identity.M31;
        *(*((IntPtr*) vectorPtr)) = new Vector3(this.M11, this.M12, this.M13);
        *(*((IntPtr*) (vectorPtr + 1))) = new Vector3(this.M21, this.M22, this.M23);
        *(*((IntPtr*) (vectorPtr + 2))) = new Vector3(this.M31, this.M32, this.M33);
        scale.X = *(((IntPtr*) vectorPtr)).Length();
        scale.Y = *(((IntPtr*) (vectorPtr + 1))).Length();
        scale.Z = *(((IntPtr*) (vectorPtr + 2))).Length();
        float num11 = numRef[0];
        float num10 = numRef[4];
        float num7 = numRef[8];
        if (num11 < num10)
        {
            if (num10 < num7)
            {
                num = 2;
                num3 = 1;
                num4 = 0;
            }
            else
            {
                num = 1;
                if (num11 < num7)
                {
                    num3 = 2;
                    num4 = 0;
                }
                else
                {
                    num3 = 0;
                    num4 = 2;
                }
            }
        }
        else if (num11 < num7)
        {
            num = 2;
            num3 = 0;
            num4 = 1;
        }
        else
        {
            num = 0;
            if (num10 < num7)
            {
                num3 = 2;
                num4 = 1;
            }
            else
            {
                num3 = 1;
                num4 = 2;
            }
        }
        if (numRef[num * 4] < 0.0001f)
        {
            *(*((IntPtr*) (vectorPtr + (num * sizeof(Vector3*))))) = vectorPtr2[(int) (num * sizeof(Vector3))];
        }
        *(((IntPtr*) (vectorPtr + (num * sizeof(Vector3*))))).Normalize();
        if (numRef[num3 * 4] < 0.0001f)
        {
            uint num5;
            float num9 = Math.Abs(*(((IntPtr*) (vectorPtr + (num * sizeof(Vector3*))))).X);
            float num8 = Math.Abs(*(((IntPtr*) (vectorPtr + (num * sizeof(Vector3*))))).Y);
            float num6 = Math.Abs(*(((IntPtr*) (vectorPtr + (num * sizeof(Vector3*))))).Z);
            if (num9 < num8)
            {
                if (num8 < num6)
                {
                    num5 = 0;
                }
                else if (num9 < num6)
                {
                    num5 = 0;
                }
                else
                {
                    num5 = 2;
                }
            }
            else if (num9 < num6)
            {
                num5 = 1;
            }
            else if (num8 < num6)
            {
                num5 = 1;
            }
            else
            {
                num5 = 2;
            }
            Vector3.Cross(ref (Vector3) ref *(((IntPtr*) (vectorPtr + (num3 * sizeof(Vector3*))))), ref (Vector3) ref *(((IntPtr*) (vectorPtr + (num * sizeof(Vector3*))))), out (Vector3) ref (vectorPtr2 + (num5 * sizeof(Vector3))));
        }
        *(((IntPtr*) (vectorPtr + (num3 * sizeof(Vector3*))))).Normalize();
        if (numRef[num4 * 4] < 0.0001f)
        {
            Vector3.Cross(ref (Vector3) ref *(((IntPtr*) (vectorPtr + (num4 * sizeof(Vector3*))))), ref (Vector3) ref *(((IntPtr*) (vectorPtr + (num * sizeof(Vector3*))))), out (Vector3) ref *(((IntPtr*) (vectorPtr + (num3 * sizeof(Vector3*))))));
        }
        *(((IntPtr*) (vectorPtr + (num4 * sizeof(Vector3*))))).Normalize();
        float num2 = identity.Determinant();
        if (num2 < 0f)
        {
            numRef[num * 4] = -numRef[num * 4];
            *(*((IntPtr*) (vectorPtr + (num * sizeof(Vector3*))))) = -*(*(((IntPtr*) (vectorPtr + (num * sizeof(Vector3*))))));
            num2 = -num2;
        }
        num2--;
        num2 *= num2;
        if (0.0001f < num2)
        {
            rotation = Quaternion.Identity;
            flag = false;
        }
        else
        {
            Quaternion.CreateFromRotationMatrix(ref identity, out rotation);
        }
    }
    return flag;
}

 
public float Determinant()
{
    float num22 = this.M11;
    float num21 = this.M12;
    float num20 = this.M13;
    float num19 = this.M14;
    float num12 = this.M21;
    float num11 = this.M22;
    float num10 = this.M23;
    float num9 = this.M24;
    float num8 = this.M31;
    float num7 = this.M32;
    float num6 = this.M33;
    float num5 = this.M34;
    float num4 = this.M41;
    float num3 = this.M42;
    float num2 = this.M43;
    float num = this.M44;
    float num18 = (num6 * num) - (num5 * num2);
    float num17 = (num7 * num) - (num5 * num3);
    float num16 = (num7 * num2) - (num6 * num3);
    float num15 = (num8 * num) - (num5 * num4);
    float num14 = (num8 * num2) - (num6 * num4);
    float num13 = (num8 * num3) - (num7 * num4);
    return ((((num22 * (((num11 * num18) - (num10 * num17)) + (num9 * num16))) - (num21 * (((num12 * num18) - (num10 * num15)) + (num9 * num14)))) + (num20 * (((num12 * num17) - (num11 * num15)) + (num9 * num13)))) - (num19 * (((num12 * num16) - (num11 * num14)) + (num10 * num13))));
}