Пример #1
0
 public static bool Equals(Matrix3F matrix1, Matrix3F matrix2)
 {
     if (matrix1.IsDistinguishedIdentity || matrix2.IsDistinguishedIdentity)
     {
         return(matrix1.IsIdentity == matrix2.IsIdentity);
     }
     else
     {
         return(matrix1.M11.Equals(matrix2.M11) &&
                matrix1.M12.Equals(matrix2.M12) &&
                matrix1.M13.Equals(matrix2.M13) &&
                matrix1.M14.Equals(matrix2.M14) &&
                matrix1.M21.Equals(matrix2.M21) &&
                matrix1.M22.Equals(matrix2.M22) &&
                matrix1.M23.Equals(matrix2.M23) &&
                matrix1.M24.Equals(matrix2.M24) &&
                matrix1.M31.Equals(matrix2.M31) &&
                matrix1.M32.Equals(matrix2.M32) &&
                matrix1.M33.Equals(matrix2.M33) &&
                matrix1.M34.Equals(matrix2.M34) &&
                matrix1.OffsetX.Equals(matrix2.OffsetX) &&
                matrix1.OffsetY.Equals(matrix2.OffsetY) &&
                matrix1.OffsetZ.Equals(matrix2.OffsetZ) &&
                matrix1.M44.Equals(matrix2.M44));
     }
 }
Пример #2
0
        private static Matrix3F CreateIdentity()
        {
            // Don't call this function, use s_identity.
            Matrix3F matrix = new Matrix3F(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);

            matrix.IsDistinguishedIdentity = true;
            return(matrix);
        }
Пример #3
0
        public override bool Equals(object o)
        {
            if ((null == o) || !(o is Matrix3F))
            {
                return(false);
            }

            Matrix3F value = (Matrix3F)o;

            return(Matrix3F.Equals(this, value));
        }
Пример #4
0
        public static Matrix3F operator *(Matrix3F matrix1, Matrix3F matrix2)
        {
            // Check if multiplying by identity.
            if (matrix1.IsDistinguishedIdentity)
            {
                return(matrix2);
            }
            if (matrix2.IsDistinguishedIdentity)
            {
                return(matrix1);
            }

            // Regular 4x4 matrix multiplication.
            Matrix3F result = new Matrix3F(
                matrix1._m11 * matrix2._m11 + matrix1._m12 * matrix2._m21 +
                matrix1._m13 * matrix2._m31 + matrix1._m14 * matrix2._offsetX,
                matrix1._m11 * matrix2._m12 + matrix1._m12 * matrix2._m22 +
                matrix1._m13 * matrix2._m32 + matrix1._m14 * matrix2._offsetY,
                matrix1._m11 * matrix2._m13 + matrix1._m12 * matrix2._m23 +
                matrix1._m13 * matrix2._m33 + matrix1._m14 * matrix2._offsetZ,
                matrix1._m11 * matrix2._m14 + matrix1._m12 * matrix2._m24 +
                matrix1._m13 * matrix2._m34 + matrix1._m14 * matrix2._m44,
                matrix1._m21 * matrix2._m11 + matrix1._m22 * matrix2._m21 +
                matrix1._m23 * matrix2._m31 + matrix1._m24 * matrix2._offsetX,
                matrix1._m21 * matrix2._m12 + matrix1._m22 * matrix2._m22 +
                matrix1._m23 * matrix2._m32 + matrix1._m24 * matrix2._offsetY,
                matrix1._m21 * matrix2._m13 + matrix1._m22 * matrix2._m23 +
                matrix1._m23 * matrix2._m33 + matrix1._m24 * matrix2._offsetZ,
                matrix1._m21 * matrix2._m14 + matrix1._m22 * matrix2._m24 +
                matrix1._m23 * matrix2._m34 + matrix1._m24 * matrix2._m44,
                matrix1._m31 * matrix2._m11 + matrix1._m32 * matrix2._m21 +
                matrix1._m33 * matrix2._m31 + matrix1._m34 * matrix2._offsetX,
                matrix1._m31 * matrix2._m12 + matrix1._m32 * matrix2._m22 +
                matrix1._m33 * matrix2._m32 + matrix1._m34 * matrix2._offsetY,
                matrix1._m31 * matrix2._m13 + matrix1._m32 * matrix2._m23 +
                matrix1._m33 * matrix2._m33 + matrix1._m34 * matrix2._offsetZ,
                matrix1._m31 * matrix2._m14 + matrix1._m32 * matrix2._m24 +
                matrix1._m33 * matrix2._m34 + matrix1._m34 * matrix2._m44,
                matrix1._offsetX * matrix2._m11 + matrix1._offsetY * matrix2._m21 +
                matrix1._offsetZ * matrix2._m31 + matrix1._m44 * matrix2._offsetX,
                matrix1._offsetX * matrix2._m12 + matrix1._offsetY * matrix2._m22 +
                matrix1._offsetZ * matrix2._m32 + matrix1._m44 * matrix2._offsetY,
                matrix1._offsetX * matrix2._m13 + matrix1._offsetY * matrix2._m23 +
                matrix1._offsetZ * matrix2._m33 + matrix1._m44 * matrix2._offsetZ,
                matrix1._offsetX * matrix2._m14 + matrix1._offsetY * matrix2._m24 +
                matrix1._offsetZ * matrix2._m34 + matrix1._m44 * matrix2._m44);

            return(result);
        }
Пример #5
0
        internal static Matrix3F CreateRotationMatrix(ref QuaternionF quaternion, ref Point3F center)
        {
            Matrix3F matrix = s_identity;

            matrix.IsDistinguishedIdentity = false; // Will be using direct member access
            Float wx, wy, wz, xx, yy, yz, xy, xz, zz, x2, y2, z2;

            x2 = quaternion.X + quaternion.X;
            y2 = quaternion.Y + quaternion.Y;
            z2 = quaternion.Z + quaternion.Z;
            xx = quaternion.X * x2;
            xy = quaternion.X * y2;
            xz = quaternion.X * z2;
            yy = quaternion.Y * y2;
            yz = quaternion.Y * z2;
            zz = quaternion.Z * z2;
            wx = quaternion.W * x2;
            wy = quaternion.W * y2;
            wz = quaternion.W * z2;

            matrix._m11 = (Float)1.0 - (yy + zz);
            matrix._m12 = xy + wz;
            matrix._m13 = xz - wy;
            matrix._m21 = xy - wz;
            matrix._m22 = (Float)1.0 - (xx + zz);
            matrix._m23 = yz + wx;
            matrix._m31 = xz + wy;
            matrix._m32 = yz - wx;
            matrix._m33 = (Float)1.0 - (xx + yy);

            if (center.X != 0 || center.Y != 0 || center.Z != 0)
            {
                matrix._offsetX = -center.X * matrix._m11 - center.Y * matrix._m21 - center.Z * matrix._m31 + center.X;
                matrix._offsetY = -center.X * matrix._m12 - center.Y * matrix._m22 - center.Z * matrix._m32 + center.Y;
                matrix._offsetZ = -center.X * matrix._m13 - center.Y * matrix._m23 - center.Z * matrix._m33 + center.Z;
            }

            return(matrix);
        }
Пример #6
0
 public static Point4F Multiply(Point4F point, Matrix3F matrix)
 {
     return(matrix.Transform(point));
 }
Пример #7
0
 public void Append(Matrix3F matrix)
 {
     this *= matrix;
 }
Пример #8
0
 public void Prepend(Matrix3F matrix)
 {
     this = matrix * this;
 }
Пример #9
0
 public static Matrix3F Multiply(Matrix3F matrix1, Matrix3F matrix2)
 {
     return(matrix1 * matrix2);
 }
Пример #10
0
 public bool Equals(Matrix3F value)
 {
     return(Matrix3F.Equals(this, value));
 }
Пример #11
0
 public static Vector3F Multiply(Vector3F vector, Matrix3F matrix)
 {
     return(matrix.Transform(vector));
 }