◆ Decompose()

unsafe bool Microsoft.Xna.Framework.Matrix.Decompose	(	out Vector3	scale,
		out Quaternion	rotation,
		out Vector3	translation )
inline
Definition at line 1364 of file Matrix.cs.
    {
        bool result = true;
        fixed (float* ptr3 = &scale.X)
        {
            VectorBasis vectorBasis = default(VectorBasis);
            Vector3** ptr = (Vector3**)(&vectorBasis);
            Matrix matrix = Identity;
            CanonicalBasis canonicalBasis = default(CanonicalBasis);
            Vector3* ptr2 = &canonicalBasis.Row0;
            canonicalBasis.Row0 = new Vector3(1f, 0f, 0f);
            canonicalBasis.Row1 = new Vector3(0f, 1f, 0f);
            canonicalBasis.Row2 = new Vector3(0f, 0f, 1f);
            translation.X = M41;
            translation.Y = M42;
            translation.Z = M43;
            *ptr = (Vector3*)(&matrix.M11);
            ptr[1] = (Vector3*)(&matrix.M21);
            ptr[2] = (Vector3*)(&matrix.M31);
            *(*ptr) = new Vector3(M11, M12, M13);
            *ptr[1] = new Vector3(M21, M22, M23);
            *ptr[2] = new Vector3(M31, M32, M33);
            scale.X = (*ptr)->Length();
            scale.Y = ptr[1]->Length();
            scale.Z = ptr[2]->Length();
            float num = *ptr3;
            float num2 = ptr3[1];
            float num3 = ptr3[2];
            uint num4;
            uint num5;
            uint num6;
            if (num < num2)
            {
                if (num2 < num3)
                {
                    num4 = 2u;
                    num5 = 1u;
                    num6 = 0u;
                }
                else
                {
                    num4 = 1u;
                    if (num < num3)
                    {
                        num5 = 2u;
                        num6 = 0u;
                    }
                    else
                    {
                        num5 = 0u;
                        num6 = 2u;
                    }
                }
            }
            else if (num < num3)
            {
                num4 = 2u;
                num5 = 0u;
                num6 = 1u;
            }
            else
            {
                num4 = 0u;
                if (num2 < num3)
                {
                    num5 = 2u;
                    num6 = 1u;
                }
                else
                {
                    num5 = 1u;
                    num6 = 2u;
                }
            }
            if (ptr3[num4] < 0.0001f)
            {
                *ptr[num4] = ptr2[num4];
            }
            ptr[num4]->Normalize();
            if (ptr3[num5] < 0.0001f)
            {
                float num7 = Math.Abs(ptr[num4]->X);
                float num8 = Math.Abs(ptr[num4]->Y);
                float num9 = Math.Abs(ptr[num4]->Z);
                uint num10 = ((num7 < num8) ? ((!(num8 < num9)) ? ((!(num7 < num9)) ? 2u : 0u) : 0u) : ((num7 < num9) ? 1u : ((num8 < num9) ? 1u : 2u)));
                Vector3.Cross(ref *ptr[num5], ref *ptr[num4], out ptr2[num10]);
            }
            ptr[num5]->Normalize();
            if (ptr3[num6] < 0.0001f)
            {
                Vector3.Cross(ref *ptr[num6], ref *ptr[num4], out *ptr[num5]);
            }
            ptr[num6]->Normalize();
            float num11 = matrix.Determinant();
            if (num11 < 0f)
            {
                ptr3[num4] = 0f - ptr3[num4];
                *ptr[num4] = -(*ptr[num4]);
                num11 = 0f - num11;
            }
            num11 -= 1f;
            num11 *= num11;
            if (0.0001f < num11)
            {
                rotation = Quaternion.Identity;
                result = false;
            }
            else
            {
                Quaternion.CreateFromRotationMatrix(ref matrix, out rotation);
            }
        }
        return result;
    }