Terraria v1.4.4.9
Terraria source code documentation
Loading...
Searching...
No Matches

◆ Invert()

static bool System.Numerics.Matrix4x4.Invert ( Matrix4x4 matrix,
out Matrix4x4 result )
inlinestatic

Definition at line 855 of file Matrix4x4.cs.

856 {
857 if (Sse.IsSupported)
858 {
859 return SseImpl(matrix, out result);
860 }
861 return SoftwareFallback(matrix, out result);
862 static bool SoftwareFallback(Matrix4x4 matrix, out Matrix4x4 result)
863 {
864 float m = matrix.M11;
865 float m2 = matrix.M12;
866 float m3 = matrix.M13;
867 float m4 = matrix.M14;
868 float m5 = matrix.M21;
869 float m6 = matrix.M22;
870 float m7 = matrix.M23;
871 float m8 = matrix.M24;
872 float m9 = matrix.M31;
873 float m10 = matrix.M32;
874 float m11 = matrix.M33;
875 float m12 = matrix.M34;
876 float m13 = matrix.M41;
877 float m14 = matrix.M42;
878 float m15 = matrix.M43;
879 float m16 = matrix.M44;
880 float num = m11 * m16 - m12 * m15;
881 float num2 = m10 * m16 - m12 * m14;
882 float num3 = m10 * m15 - m11 * m14;
883 float num4 = m9 * m16 - m12 * m13;
884 float num5 = m9 * m15 - m11 * m13;
885 float num6 = m9 * m14 - m10 * m13;
886 float num7 = m6 * num - m7 * num2 + m8 * num3;
887 float num8 = 0f - (m5 * num - m7 * num4 + m8 * num5);
888 float num9 = m5 * num2 - m6 * num4 + m8 * num6;
889 float num10 = 0f - (m5 * num3 - m6 * num5 + m7 * num6);
890 float num11 = m * num7 + m2 * num8 + m3 * num9 + m4 * num10;
891 if (MathF.Abs(num11) < float.Epsilon)
892 {
893 result = new Matrix4x4(float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN);
894 return false;
895 }
896 float num12 = 1f / num11;
897 result.M11 = num7 * num12;
898 result.M21 = num8 * num12;
899 result.M31 = num9 * num12;
900 result.M41 = num10 * num12;
901 result.M12 = (0f - (m2 * num - m3 * num2 + m4 * num3)) * num12;
902 result.M22 = (m * num - m3 * num4 + m4 * num5) * num12;
903 result.M32 = (0f - (m * num2 - m2 * num4 + m4 * num6)) * num12;
904 result.M42 = (m * num3 - m2 * num5 + m3 * num6) * num12;
905 float num13 = m7 * m16 - m8 * m15;
906 float num14 = m6 * m16 - m8 * m14;
907 float num15 = m6 * m15 - m7 * m14;
908 float num16 = m5 * m16 - m8 * m13;
909 float num17 = m5 * m15 - m7 * m13;
910 float num18 = m5 * m14 - m6 * m13;
911 result.M13 = (m2 * num13 - m3 * num14 + m4 * num15) * num12;
912 result.M23 = (0f - (m * num13 - m3 * num16 + m4 * num17)) * num12;
913 result.M33 = (m * num14 - m2 * num16 + m4 * num18) * num12;
914 result.M43 = (0f - (m * num15 - m2 * num17 + m3 * num18)) * num12;
915 float num19 = m7 * m12 - m8 * m11;
916 float num20 = m6 * m12 - m8 * m10;
917 float num21 = m6 * m11 - m7 * m10;
918 float num22 = m5 * m12 - m8 * m9;
919 float num23 = m5 * m11 - m7 * m9;
920 float num24 = m5 * m10 - m6 * m9;
921 result.M14 = (0f - (m2 * num19 - m3 * num20 + m4 * num21)) * num12;
922 result.M24 = (m * num19 - m3 * num22 + m4 * num23) * num12;
923 result.M34 = (0f - (m * num20 - m2 * num22 + m4 * num24)) * num12;
924 result.M44 = (m * num21 - m2 * num23 + m3 * num24) * num12;
925 return true;
926 }
927 unsafe static bool SseImpl(Matrix4x4 matrix, out Matrix4x4 result)
928 {
929 if (!Sse.IsSupported)
930 {
931 throw new PlatformNotSupportedException();
932 }
933 Vector128<float> left = Sse.LoadVector128(&matrix.M11);
934 Vector128<float> right = Sse.LoadVector128(&matrix.M21);
935 Vector128<float> left2 = Sse.LoadVector128(&matrix.M31);
936 Vector128<float> right2 = Sse.LoadVector128(&matrix.M41);
937 Vector128<float> left3 = Sse.Shuffle(left, right, 68);
938 Vector128<float> left4 = Sse.Shuffle(left, right, 238);
939 Vector128<float> right3 = Sse.Shuffle(left2, right2, 68);
940 Vector128<float> right4 = Sse.Shuffle(left2, right2, 238);
941 left = Sse.Shuffle(left3, right3, 136);
942 right = Sse.Shuffle(left3, right3, 221);
943 left2 = Sse.Shuffle(left4, right4, 136);
944 right2 = Sse.Shuffle(left4, right4, 221);
945 Vector128<float> left5 = Permute(left2, 80);
946 Vector128<float> right5 = Permute(right2, 238);
947 Vector128<float> left6 = Permute(left, 80);
948 Vector128<float> right6 = Permute(right, 238);
949 Vector128<float> left7 = Sse.Shuffle(left2, left, 136);
950 Vector128<float> right7 = Sse.Shuffle(right2, right, 221);
951 Vector128<float> left8 = Sse.Multiply(left5, right5);
952 Vector128<float> left9 = Sse.Multiply(left6, right6);
953 Vector128<float> left10 = Sse.Multiply(left7, right7);
954 left5 = Permute(left2, 238);
955 right5 = Permute(right2, 80);
956 left6 = Permute(left, 238);
957 right6 = Permute(right, 80);
958 left7 = Sse.Shuffle(left2, left, 221);
959 right7 = Sse.Shuffle(right2, right, 136);
960 left8 = Sse.Subtract(left8, Sse.Multiply(left5, right5));
961 left9 = Sse.Subtract(left9, Sse.Multiply(left6, right6));
962 left10 = Sse.Subtract(left10, Sse.Multiply(left7, right7));
963 right6 = Sse.Shuffle(left8, left10, 93);
964 left5 = Permute(right, 73);
965 right5 = Sse.Shuffle(right6, left8, 50);
966 left6 = Permute(left, 18);
967 right6 = Sse.Shuffle(right6, left8, 153);
968 Vector128<float> left11 = Sse.Shuffle(left9, left10, 253);
969 left7 = Permute(right2, 73);
970 right7 = Sse.Shuffle(left11, left9, 50);
971 Vector128<float> left12 = Permute(left2, 18);
972 left11 = Sse.Shuffle(left11, left9, 153);
973 Vector128<float> left13 = Sse.Multiply(left5, right5);
974 Vector128<float> left14 = Sse.Multiply(left6, right6);
975 Vector128<float> left15 = Sse.Multiply(left7, right7);
976 Vector128<float> left16 = Sse.Multiply(left12, left11);
977 right6 = Sse.Shuffle(left8, left10, 4);
978 left5 = Permute(right, 158);
979 right5 = Sse.Shuffle(left8, right6, 147);
980 left6 = Permute(left, 123);
981 right6 = Sse.Shuffle(left8, right6, 38);
982 left11 = Sse.Shuffle(left9, left10, 164);
983 left7 = Permute(right2, 158);
984 right7 = Sse.Shuffle(left9, left11, 147);
985 left12 = Permute(left2, 123);
986 left11 = Sse.Shuffle(left9, left11, 38);
987 left13 = Sse.Subtract(left13, Sse.Multiply(left5, right5));
988 left14 = Sse.Subtract(left14, Sse.Multiply(left6, right6));
989 left15 = Sse.Subtract(left15, Sse.Multiply(left7, right7));
990 left16 = Sse.Subtract(left16, Sse.Multiply(left12, left11));
991 left5 = Permute(right, 51);
992 right5 = Sse.Shuffle(left8, left10, 74);
993 right5 = Permute(right5, 44);
994 left6 = Permute(left, 141);
995 right6 = Sse.Shuffle(left8, left10, 76);
996 right6 = Permute(right6, 147);
997 left7 = Permute(right2, 51);
998 right7 = Sse.Shuffle(left9, left10, 234);
999 right7 = Permute(right7, 44);
1000 left12 = Permute(left2, 141);
1001 left11 = Sse.Shuffle(left9, left10, 236);
1002 left11 = Permute(left11, 147);
1003 left5 = Sse.Multiply(left5, right5);
1004 left6 = Sse.Multiply(left6, right6);
1005 left7 = Sse.Multiply(left7, right7);
1006 left12 = Sse.Multiply(left12, left11);
1007 Vector128<float> right8 = Sse.Subtract(left13, left5);
1008 left13 = Sse.Add(left13, left5);
1009 Vector128<float> right9 = Sse.Add(left14, left6);
1010 left14 = Sse.Subtract(left14, left6);
1011 Vector128<float> right10 = Sse.Subtract(left15, left7);
1012 left15 = Sse.Add(left15, left7);
1013 Vector128<float> right11 = Sse.Add(left16, left12);
1014 left16 = Sse.Subtract(left16, left12);
1015 left13 = Sse.Shuffle(left13, right8, 216);
1016 left14 = Sse.Shuffle(left14, right9, 216);
1017 left15 = Sse.Shuffle(left15, right10, 216);
1018 left16 = Sse.Shuffle(left16, right11, 216);
1019 left13 = Permute(left13, 216);
1020 left14 = Permute(left14, 216);
1021 left15 = Permute(left15, 216);
1022 left16 = Permute(left16, 216);
1023 right3 = left;
1024 float num25 = Vector4.Dot(left13.AsVector4(), right3.AsVector4());
1025 if (MathF.Abs(num25) < float.Epsilon)
1026 {
1027 result = new Matrix4x4(float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN);
1028 return false;
1029 }
1030 Vector128<float> left17 = Vector128.Create(1f);
1031 Vector128<float> right12 = Vector128.Create(num25);
1032 right12 = Sse.Divide(left17, right12);
1033 left = Sse.Multiply(left13, right12);
1034 right = Sse.Multiply(left14, right12);
1035 left2 = Sse.Multiply(left15, right12);
1036 right2 = Sse.Multiply(left16, right12);
1037 Unsafe.SkipInit<Matrix4x4>(out result);
1038 ref Vector128<float> reference = ref Unsafe.As<Matrix4x4, Vector128<float>>(ref result);
1039 reference = left;
1040 Unsafe.Add(ref reference, 1) = right;
1041 Unsafe.Add(ref reference, 2) = left2;
1042 Unsafe.Add(ref reference, 3) = right2;
1043 return true;
1044 }
1045 }
System.Runtime.Intrinsics.Vector128.Create
static Vector128< byte > Create(byte value)
Definition Vector128.cs:138
System.Runtime.Intrinsics.Vector128.AsVector4
static Vector4 AsVector4(this Vector128< float > value)
Definition Vector128.cs:123
System.Runtime.Intrinsics.X86.Sse.IsSupported
static new bool IsSupported
Definition Sse.cs:30
System.Runtime.Intrinsics.X86.Sse.LoadVector128
static unsafe Vector128< float > LoadVector128(float *address)
Definition Sse.cs:257
System.Runtime.Intrinsics.X86.Sse.Shuffle
static Vector128< float > Shuffle(Vector128< float > left, Vector128< float > right, byte control)
Definition Sse.cs:387
System.Runtime.Intrinsics.X86.Sse.Multiply
static Vector128< float > Multiply(Vector128< float > left, Vector128< float > right)
Definition Sse.cs:322
System.Runtime.Intrinsics.X86.Sse.Add
static Vector128< float > Add(Vector128< float > left, Vector128< float > right)
Definition Sse.cs:32
System.Runtime.Intrinsics.X86.Sse.Subtract
static Vector128< float > Subtract(Vector128< float > left, Vector128< float > right)
Definition Sse.cs:442
System.Runtime.Intrinsics.X86.Sse.Divide
static Vector128< float > Divide(Vector128< float > left, Vector128< float > right)
Definition Sse.cs:247
System.Numerics.Matrix4x4.Matrix4x4
Matrix4x4(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
Definition Matrix4x4.cs:93
System.Numerics.Matrix4x4.Permute
static Vector128< float > Permute(Vector128< float > value, byte control)
Definition Matrix4x4.cs:1072

References System.Numerics.Matrix4x4.Matrix4x4(), System.MathF.Abs(), System.Runtime.Intrinsics.X86.Sse.Add(), System.Runtime.Intrinsics.Vector128< T >.AsVector4(), System.Runtime.Intrinsics.Vector128< T >.Create(), System.Runtime.Intrinsics.X86.Sse.Divide(), System.Numerics.Vector4.Dot(), System.Runtime.Intrinsics.X86.Sse.IsSupported, System.Runtime.Intrinsics.X86.Sse.LoadVector128(), System.Numerics.Matrix4x4.M11, System.Numerics.Matrix4x4.M12, System.Numerics.Matrix4x4.M13, System.Numerics.Matrix4x4.M14, System.Numerics.Matrix4x4.M21, System.Numerics.Matrix4x4.M22, System.Numerics.Matrix4x4.M23, System.Numerics.Matrix4x4.M24, System.Numerics.Matrix4x4.M31, System.Numerics.Matrix4x4.M32, System.Numerics.Matrix4x4.M33, System.Numerics.Matrix4x4.M34, System.Numerics.Matrix4x4.M41, System.Numerics.Matrix4x4.M42, System.Numerics.Matrix4x4.M43, System.Numerics.Matrix4x4.M44, System.Runtime.Intrinsics.X86.Sse.Multiply(), System.Numerics.Matrix4x4.Permute(), System.Runtime.Intrinsics.X86.Sse.Shuffle(), and System.Runtime.Intrinsics.X86.Sse.Subtract().

Referenced by System.Numerics.Plane.Transform().