Example #1
0
 public Mat4f(Mat4f m)
 {
     for (int i = 0; i < Size; i++)
     {
         cols[i] = new Vec4f(m.cols[i]);
     }
 }
Example #2
0
 public void Set(Mat4f m)
 {
     for (int i = 0; i < Size; i++)
     {
         for (int j = 0; j < Size; j++)
         {
             this[i, j] = m[i, j];
         }
     }
 }
Example #3
0
        public static Mat4f Identity()
        {
            Mat4f m = new Mat4f();

            m[0, 0] = 1;
            m[1, 1] = 1;
            m[2, 2] = 1;
            m[3, 3] = 1;
            return(m);
        }
Example #4
0
        public static Mat4f operator *(Mat4f l, Mat4f r)
        {
            Mat4f Result = new Mat4f();

            for (int i = 0; i < Size; i++)
            {
                for (int j = 0; j < Size; j++)
                {
                    for (int k = 0; k < Size; k++)
                    {
                        Result[i, j] += l[i, k] * r[k, j];
                    }
                }
            }
            return(Result);
        }
Example #5
0
        public void Rotate(float angle, Vec3f v)
        {
            var a = angle;
            var c = (float)Math.Cos(a);
            var s = (float)Math.Sin(a);

            Vec3f axis = v.CreateNormalizedVector();
            Vec3f temp = (1 - c) * axis;

            Mat4f Rotate = new Mat4f();

            Rotate[0][0] = c + temp[0] * axis[0];
            Rotate[0][1] = temp[0] * axis[1] + s * axis[2];
            Rotate[0][2] = temp[0] * axis[2] - s * axis[1];

            Rotate[1][0] = temp[1] * axis[0] - s * axis[2];
            Rotate[1][1] = c + temp[1] * axis[1];
            Rotate[1][2] = temp[1] * axis[2] + s * axis[0];

            Rotate[2][0] = temp[2] * axis[0] + s * axis[1];
            Rotate[2][1] = temp[2] * axis[1] - s * axis[0];
            Rotate[2][2] = c + temp[2] * axis[2];

            Mat4f Result = new Mat4f();

            Result[0] = this[0] * Rotate[0][0] + this[1] * Rotate[0][1] + this[2] * Rotate[0][2];
            Result[1] = this[0] * Rotate[1][0] + this[1] * Rotate[1][1] + this[2] * Rotate[1][2];
            Result[2] = this[0] * Rotate[2][0] + this[1] * Rotate[2][1] + this[2] * Rotate[2][2];
            Result[3] = this[3];
            for (int i = 0; i < Size; i++)
            {
                for (int j = 0; j < Size; j++)
                {
                    Result[i, j] = (float)Result[i, j];
                }
            }
            Set(Result);
        }
Example #6
0
        public void Inverse()
        {
            //Generated with https://github.com/willnode/N-Matrix-Programmer

            var A2323 = this[2, 2] * this[3, 3] - this[2, 3] * this[3, 2];
            var A1323 = this[2, 1] * this[3, 3] - this[2, 3] * this[3, 1];
            var A1223 = this[2, 1] * this[3, 2] - this[2, 2] * this[3, 1];
            var A0323 = this[2, 0] * this[3, 3] - this[2, 3] * this[3, 0];
            var A0223 = this[2, 0] * this[3, 2] - this[2, 2] * this[3, 0];
            var A0123 = this[2, 0] * this[3, 1] - this[2, 1] * this[3, 0];
            var A2313 = this[1, 2] * this[3, 3] - this[1, 3] * this[3, 2];
            var A1313 = this[1, 1] * this[3, 3] - this[1, 3] * this[3, 1];
            var A1213 = this[1, 1] * this[3, 2] - this[1, 2] * this[3, 1];
            var A2312 = this[1, 2] * this[2, 3] - this[1, 3] * this[2, 2];
            var A1312 = this[1, 1] * this[2, 3] - this[1, 3] * this[2, 1];
            var A1212 = this[1, 1] * this[2, 2] - this[1, 2] * this[2, 1];
            var A0313 = this[1, 0] * this[3, 3] - this[1, 3] * this[3, 0];
            var A0213 = this[1, 0] * this[3, 2] - this[1, 2] * this[3, 0];
            var A0312 = this[1, 0] * this[2, 3] - this[1, 3] * this[2, 0];
            var A0212 = this[1, 0] * this[2, 2] - this[1, 2] * this[2, 0];
            var A0113 = this[1, 0] * this[3, 1] - this[1, 1] * this[3, 0];
            var A0112 = this[1, 0] * this[2, 1] - this[1, 1] * this[2, 0];

            var det = this[0, 0] * (this[1, 1] * A2323 - this[1, 2] * A1323 + this[1, 3] * A1223)
                      - this[0, 1] * (this[1, 0] * A2323 - this[1, 2] * A0323 + this[1, 3] * A0223)
                      + this[0, 2] * (this[1, 0] * A1323 - this[1, 1] * A0323 + this[1, 3] * A0123)
                      - this[0, 3] * (this[1, 0] * A1223 - this[1, 1] * A0223 + this[1, 2] * A0123);

            if (det == 0)
            {
                throw new Exception("Error: determinant is zero can't calculate inverse");
            }

            det = 1 / det;

            Mat4f r = new Mat4f();

            r[0, 0] = det * (this[1, 1] * A2323 - this[1, 2] * A1323 + this[1, 3] * A1223);
            r[0, 1] = det * -(this[0, 1] * A2323 - this[0, 2] * A1323 + this[0, 3] * A1223);
            r[0, 2] = det * (this[0, 1] * A2313 - this[0, 2] * A1313 + this[0, 3] * A1213);
            r[0, 3] = det * -(this[0, 1] * A2312 - this[0, 2] * A1312 + this[0, 3] * A1212);
            r[1, 0] = det * -(this[1, 0] * A2323 - this[1, 2] * A0323 + this[1, 3] * A0223);
            r[1, 1] = det * (this[0, 0] * A2323 - this[0, 2] * A0323 + this[0, 3] * A0223);
            r[1, 2] = det * -(this[0, 0] * A2313 - this[0, 2] * A0313 + this[0, 3] * A0213);
            r[1, 3] = det * (this[0, 0] * A2312 - this[0, 2] * A0312 + this[0, 3] * A0212);
            r[2, 0] = det * (this[1, 0] * A1323 - this[1, 1] * A0323 + this[1, 3] * A0123);
            r[2, 1] = det * -(this[0, 0] * A1323 - this[0, 1] * A0323 + this[0, 3] * A0123);
            r[2, 2] = det * (this[0, 0] * A1313 - this[0, 1] * A0313 + this[0, 3] * A0113);
            r[2, 3] = det * -(this[0, 0] * A1312 - this[0, 1] * A0312 + this[0, 3] * A0112);
            r[3, 0] = det * -(this[1, 0] * A1223 - this[1, 1] * A0223 + this[1, 2] * A0123);
            r[3, 1] = det * (this[0, 0] * A1223 - this[0, 1] * A0223 + this[0, 2] * A0123);
            r[3, 2] = det * -(this[0, 0] * A1213 - this[0, 1] * A0213 + this[0, 2] * A0113);
            r[3, 3] = det * (this[0, 0] * A1212 - this[0, 1] * A0212 + this[0, 2] * A0112);

            for (int i = 0; i < Size; i++)
            {
                for (int j = 0; j < Size; j++)
                {
                    this[i, j] = r[i, j];
                }
            }
        }