Exemple #1
0
        /// <summary>
        /// Make an orthogonal matrix
        /// </summary>
        /// <param name="left">Left value</param>
        /// <param name="right">Right value</param>
        /// <param name="bottom">Bottom value</param>
        /// <param name="top">Top value</param>
        /// <param name="zNear">Near z plane distance</param>
        /// <param name="zFar">Far z plane distance</param>
        /// <returns>Frustrum matrix</returns>
        public static GLMatrix4D Orthogonal(double left, double right, double bottom, double top, double zNear, double zFar)
        {
            GLMatrix4D ret = new GLMatrix4D();

            ret.m[0] = 2 / (right - left);
            ret.m[1] = 0;
            ret.m[2] = 0;
            ret.m[3] = 0;

            ret.m[4] = 0;
            ret.m[5] = 2 / (top - bottom);
            ret.m[6] = 0;
            ret.m[7] = 0;

            ret.m[8]  = 0;
            ret.m[9]  = 0;
            ret.m[10] = -2 / (zFar - zNear);
            ret.m[11] = 0;

            ret.m[12] = -(right + left) / (right - left);
            ret.m[13] = -(top + bottom) / (top - bottom);
            ret.m[14] = -(zFar + zNear) / (zFar - zNear);
            ret.m[15] = 1;

            return(ret);
        }
Exemple #2
0
        /// <summary>
        /// Get the matrix dot product, the most commonly used form of matrix multiplication
        /// </summary>
        /// <param name="one">Left Matrix</param>
        /// <param name="two">Right Matrix</param>
        /// <returns>New resulting matrix</returns>
        public static GLMatrix4D operator*(GLMatrix4D one, GLMatrix4D two)
        {
            GLMatrix4D ret = new GLMatrix4D();

            for (byte j = 0; j < 4; ++j)
            {
                ret.m[j] = one.m[j] * two.m[0]
                           + one.m[j + 4] * two.m[1]
                           + one.m[j + 8] * two.m[2]
                           + one.m[j + 12] * two.m[3];

                ret.m[j + 4] = one.m[j] * two.m[4]
                               + one.m[j + 4] * two.m[5]
                               + one.m[j + 8] * two.m[6]
                               + one.m[j + 12] * two.m[7];

                ret.m[j + 8] = one.m[j] * two.m[8]
                               + one.m[j + 4] * two.m[9]
                               + one.m[j + 8] * two.m[10]
                               + one.m[j + 12] * two.m[11];

                ret.m[j + 12] = one[j] * two.m[12]
                                + one[j + 4] * two.m[13]
                                + one[j + 8] * two.m[14]
                                + one[j + 12] * two.m[15];
            }

            return(ret);
        }
Exemple #3
0
        /// <summary>
        /// Get the adjoint matrix
        /// </summary>
        /// <returns>A new matrix that is adjoint to this one</returns>
        public GLMatrix4D adjoint()
        {
            GLMatrix4D ret = new GLMatrix4D();

            ret.m[0] = CofactorM0();
            ret.m[1] = -CofactorM4();
            ret.m[2] = CofactorM8();
            ret.m[3] = -CofactorM12();

            ret.m[4] = -CofactorM1();
            ret.m[5] = CofactorM5();
            ret.m[6] = -CofactorM9();
            ret.m[7] = CofactorM13();

            ret.m[8]  = CofactorM2();
            ret.m[9]  = -CofactorM6();
            ret.m[10] = CofactorM10();
            ret.m[11] = -CofactorM14();

            ret.m[12] = -CofactorM3();
            ret.m[13] = CofactorM7();
            ret.m[14] = -CofactorM11();
            ret.m[15] = CofactorM15();

            return(ret);
        }
Exemple #4
0
        /// <summary>
        /// Create a frustrum matrix
        /// </summary>
        /// <param name="left">Left value</param>
        /// <param name="right">Right value</param>
        /// <param name="bottom">Bottom value</param>
        /// <param name="top">Top value</param>
        /// <param name="zNear">Near z plane distance</param>
        /// <param name="zFar">Far z plane distance</param>
        /// <returns>Frustrum matrix</returns>
        public static GLMatrix4D glFrustrum(double left, double right, double bottom, double top, double zNear, double zFar)
        {
            GLMatrix4D ret = new GLMatrix4D();

            ret.m[0] = 2 * zNear / (right - left);
            ret.m[1] = 0;
            ret.m[2] = 0;
            ret.m[3] = 0;

            ret.m[4] = 0;
            ret.m[5] = 2 * zNear / (top - bottom);
            ret.m[6] = 0;
            ret.m[7] = 0;

            ret.m[8]  = (right + left) / (right - left);
            ret.m[9]  = (top + bottom) / (top - bottom);
            ret.m[10] = -(zFar + zNear) / (zFar - zNear);
            ret.m[11] = -1;

            ret.m[12] = 0;
            ret.m[13] = 0;
            ret.m[14] = -2 * zFar * zNear / (zFar - zNear);
            ret.m[15] = 0;

            return(ret);
        }
Exemple #5
0
        public static void ApplyRotToGLMatrix4d( ref GLMatrix4D matrix, Rot rot )
        {
            double fRotAngle = 0;
            Vector3 vAxis = new Vector3();
            mvMath.Rot2AxisAngle( ref vAxis, ref fRotAngle, rot );

            matrix.applyRotate( (float)( fRotAngle / mvMath.PiOver180 ), (float)vAxis.x, (float)vAxis.y, (float)vAxis.z );
        }
Exemple #6
0
        /// <summary>
        /// Apply a rotation to this matrix
        /// </summary>
        /// <param name="angle">Angle of rotation</param>
        /// <param name="x">X value of the rotation vector</param>
        /// <param name="y">Y value of the rotation vector</param>
        /// <param name="z">Z value of the rotation vector</param>
        /// <returns>This matrix</returns>
        public GLMatrix4D applyRotate(double angle, double x, double y, double z)
        {
            GLMatrix4D temp = new GLMatrix4D();

            temp.LoadRotate(angle, x, y, z);

            return(Multiply3By3(temp));
        }
Exemple #7
0
        /// <summary>
        /// Apply a Z rotation to this matrix
        /// </summary>
        /// <param name="angle">Angle of rotation</param>
        /// <returns>This matrix</returns>
        /// <remarks>Apply rotate[X,Y,Z,XYZ] specialisations by sebastien bloc</remarks>
        public GLMatrix4D ApplyRotateZ(double angle)
        {
            GLMatrix4D temp = new GLMatrix4D();

            temp.loadRotateZ(angle);

            return(Multiply3By3(temp));
        }
Exemple #8
0
        /// <summary>
        /// Identity matrix
        /// </summary>
        /// <returns>A new identity matrix</returns>
        public static GLMatrix4D Identity()
        {
            GLMatrix4D ret = new GLMatrix4D();

            ret.m[0] = 1;   ret.m[4] = 0;   ret.m[8] = 0;  ret.m[12] = 0;
            ret.m[1] = 0;   ret.m[5] = 1;   ret.m[9] = 0;  ret.m[13] = 0;
            ret.m[2] = 0;   ret.m[6] = 0;   ret.m[10] = 1;  ret.m[14] = 0;
            ret.m[3] = 0;   ret.m[7] = 0;   ret.m[11] = 0;  ret.m[15] = 1;

            return(ret);
        }
Exemple #9
0
        /// <summary>
        /// Subtract one matrix from another
        /// </summary>
        /// <param name="one">Left Matrix</param>
        /// <param name="two">Right Matrix</param>
        /// <returns>New resulting matrix</returns>
        public static GLMatrix4D operator-(GLMatrix4D one, GLMatrix4D two)
        {
            GLMatrix4D result = new GLMatrix4D();

            for (byte i = 0; i < 16; ++i)
            {
                result.m[i] = one.m[i] - two.m[i];
            }

            return(result);
        }
Exemple #10
0
        /// <summary>
        /// Divide this matrix by a scalar
        /// </summary>
        /// <param name="mat">Matrix</param>
        /// <param name="val">Scalar</param>
        /// <returns>New resulting matrix</returns>
        public static GLMatrix4D operator/(GLMatrix4D mat, double val)
        {
            GLMatrix4D result = new GLMatrix4D();

            for (byte i = 0; i < 16; ++i)
            {
                result.m[i] = mat.m[i] / val;
            }

            return(result);
        }
Exemple #11
0
        /// <summary>
        /// Adjoint method inverse, constant time inversion implementation
        /// </summary>
        /// <returns>A new matrix that is inverse to this one</returns>
        public GLMatrix4D inverse()
        {
            GLMatrix4D ret = new GLMatrix4D(adjoint());

            double determinant = m[0] * ret[0] + m[1] * ret[4] + m[2] * ret[8] + m[3] * ret[12];

            //assert(determinant!=0 && "Singular matrix has no inverse");

            ret /= determinant;

            return(ret);
        }
Exemple #12
0
        /// <summary>
        /// Apply a XYZ rotation to this matrix
        /// </summary>
        /// <param name="angle">Angle of rotation around X axis</param>
        /// <param name="angle">Angle of rotation around Y axis</param>
        /// <param name="angle">Angle of rotation around Z axis</param>
        /// <returns>This matrix</returns>
        /// <remarks>Apply rotate[X,Y,Z,XYZ] specialisations by sebastien bloc</remarks>
        public GLMatrix4D ApplyRotateXYZ(double x, double y, double z)
        {
            GLMatrix4D temp = new GLMatrix4D();

            temp.LoadRotateX(x);
            Multiply3By3(temp);
            temp.loadRotateY(y);
            Multiply3By3(temp);
            temp.loadRotateZ(z);

            return(Multiply3By3(temp));
        }
Exemple #13
0
        /// <summary>
        /// Equality function override
        /// </summary>
        /// <param name="twoobject">Matrix object</param>
        /// <returns>True if they are equal, false otherwise</returns>
        public override bool Equals(object twoobject)
        {
            GLMatrix4D two = twoobject as GLMatrix4D;

            for (int i = 0; i < 16; i++)
            {
                if (m[i] != two.m[i])
                {
                    return(false);
                }
            }

            return(true);
        }
Exemple #14
0
        //!Return the transpose

        /// <summary>
        /// Get a transposed matrix
        /// </summary>
        /// <returns>A new matrix that is the transposed form of this</returns>
        public GLMatrix4D GetTranspose()
        {
            GLMatrix4D temp = new GLMatrix4D();

            for (int i = 0; i < 4; ++i)
            {
                for (int j = 0; j < 4; ++j)
                {
                    temp.m[j + i * 4] = m[i + j * 4];
                }
            }

            return(temp);
        }
Exemple #15
0
        /// <summary>
        /// Apply the matrix dot product to this matrix
        /// </summary>
        /// <param name="mat">Right Side Matrix</param>
        /// <returns>This Matrix</returns>
        /// <remarks>unrolling by sebastien bloc</remarks>
        public GLMatrix4D Multiply3By3(GLMatrix4D mat)
        {
            GLMatrix4D temp = new GLMatrix4D(this);

            m[0] = temp.m[0] * mat.m[0] + temp.m[4] * mat.m[1] + temp.m[8] * mat.m[2];
            m[4] = temp.m[0] * mat.m[4] + temp.m[4] * mat.m[5] + temp.m[8] * mat.m[6];
            m[8] = temp.m[0] * mat.m[8] + temp.m[4] * mat.m[9] + temp.m[8] * mat.m[10];

            m[1] = temp.m[1] * mat.m[0] + temp.m[5] * mat.m[1] + temp.m[9] * mat.m[2];
            m[5] = temp.m[1] * mat.m[4] + temp.m[5] * mat.m[5] + temp.m[9] * mat.m[6];
            m[9] = temp.m[1] * mat.m[8] + temp.m[5] * mat.m[9] + temp.m[9] * mat.m[10];

            m[2]  = temp.m[2] * mat.m[0] + temp.m[6] * mat.m[1] + temp.m[10] * mat.m[2];
            m[6]  = temp.m[2] * mat.m[4] + temp.m[6] * mat.m[5] + temp.m[10] * mat.m[6];
            m[10] = temp.m[2] * mat.m[8] + temp.m[6] * mat.m[9] + temp.m[10] * mat.m[10];

            m[3]  = temp.m[3] * mat.m[0] + temp.m[7] * mat.m[1] + temp.m[11] * mat.m[2];
            m[7]  = temp.m[3] * mat.m[4] + temp.m[7] * mat.m[5] + temp.m[11] * mat.m[6];
            m[11] = temp.m[3] * mat.m[8] + temp.m[7] * mat.m[9] + temp.m[11] * mat.m[10];

            return(this);
        }
Exemple #16
0
        /// <summary>
        /// Apply a rotation to this matrix
        /// </summary>
        /// <param name="angle">Angle of rotation</param>
        /// <param name="x">X value of the rotation vector</param>
        /// <param name="y">Y value of the rotation vector</param>
        /// <param name="z">Z value of the rotation vector</param>
        /// <returns>This matrix</returns>
        public GLMatrix4D applyRotate( double angle, double x, double y, double z )
        {
            GLMatrix4D temp = new GLMatrix4D();
            temp.LoadRotate( angle,x,y,z );

            return Multiply3By3( temp );
        }
Exemple #17
0
        /// <summary>
        /// Get the adjoint matrix
        /// </summary>
        /// <returns>A new matrix that is adjoint to this one</returns>
        public GLMatrix4D adjoint()
        {
            GLMatrix4D ret = new GLMatrix4D();

            ret.m[0] = CofactorM0();
            ret.m[1] = -CofactorM4();
            ret.m[2] = CofactorM8();
            ret.m[3] = -CofactorM12();

            ret.m[4] = -CofactorM1();
            ret.m[5] = CofactorM5();
            ret.m[6] = -CofactorM9();
            ret.m[7] = CofactorM13();

            ret.m[8] = CofactorM2();
            ret.m[9] = -CofactorM6();
            ret.m[10] = CofactorM10();
            ret.m[11] = -CofactorM14();

            ret.m[12] = -CofactorM3();
            ret.m[13] = CofactorM7();
            ret.m[14] = -CofactorM11();
            ret.m[15] = CofactorM15();

            return ret;
        }
Exemple #18
0
        /// <summary>
        /// Make an orthogonal matrix
        /// </summary>
        /// <param name="left">Left value</param>
        /// <param name="right">Right value</param>
        /// <param name="bottom">Bottom value</param>
        /// <param name="top">Top value</param>
        /// <param name="zNear">Near z plane distance</param>
        /// <param name="zFar">Far z plane distance</param>
        /// <returns>Frustrum matrix</returns>
        public static GLMatrix4D Orthogonal( double left, double right, double bottom, double top, double zNear, double zFar )
        {
            GLMatrix4D ret = new GLMatrix4D();

            ret.m[0] = 2/(right-left);
            ret.m[1] = 0;
            ret.m[2] = 0;
            ret.m[3] = 0;

            ret.m[4] = 0;
            ret.m[5] = 2/(top-bottom);
            ret.m[6] = 0;
            ret.m[7] = 0;

            ret.m[8] = 0;
            ret.m[9] = 0;
            ret.m[10] = -2/(zFar-zNear);
            ret.m[11] = 0;

            ret.m[12] = -(right+left)/(right-left);
            ret.m[13] = -(top+bottom)/(top-bottom);
            ret.m[14] = -(zFar+zNear)/(zFar-zNear);
            ret.m[15] = 1;

            return ret;
        }
Exemple #19
0
        /// <summary>
        /// Identity matrix
        /// </summary>
        /// <returns>A new identity matrix</returns>
        public static GLMatrix4D Identity()
        {
            GLMatrix4D ret = new GLMatrix4D();

            ret.m[0] = 1;   ret.m[4] = 0;   ret.m[8]  = 0;  ret.m[12] = 0;
            ret.m[1] = 0;   ret.m[5] = 1;   ret.m[9]  = 0;  ret.m[13] = 0;
            ret.m[2] = 0;   ret.m[6] = 0;   ret.m[10] = 1;  ret.m[14] = 0;
            ret.m[3] = 0;   ret.m[7] = 0;   ret.m[11] = 0;  ret.m[15] = 1;

            return ret;
        }
Exemple #20
0
        /// <summary>
        /// Create a frustrum matrix
        /// </summary>
        /// <param name="left">Left value</param>
        /// <param name="right">Right value</param>
        /// <param name="bottom">Bottom value</param>
        /// <param name="top">Top value</param>
        /// <param name="zNear">Near z plane distance</param>
        /// <param name="zFar">Far z plane distance</param>
        /// <returns>Frustrum matrix</returns>
        public static GLMatrix4D glFrustrum( double left, double right, double bottom, double top, double zNear, double zFar )
        {
            GLMatrix4D ret = new GLMatrix4D();
            ret.m[0] = 2*zNear/(right-left);
            ret.m[1] = 0;
            ret.m[2] = 0;
            ret.m[3] = 0;

            ret.m[4] = 0;
            ret.m[5] = 2*zNear/(top-bottom);
            ret.m[6] = 0;
            ret.m[7] = 0;

            ret.m[8] = (right+left)/(right-left);
            ret.m[9] = (top+bottom)/(top-bottom);
            ret.m[10] = -(zFar+zNear)/(zFar-zNear);
            ret.m[11] = -1;

            ret.m[12] = 0;
            ret.m[13] = 0;
            ret.m[14] = -2*zFar*zNear/(zFar-zNear);
            ret.m[15] = 0;

            return ret;
        }
Exemple #21
0
        /// <summary>
        /// Divide this matrix by a scalar
        /// </summary>
        /// <param name="mat">Matrix</param>
        /// <param name="val">Scalar</param>
        /// <returns>New resulting matrix</returns>
        public static GLMatrix4D operator /( GLMatrix4D mat, double val)
        {
            GLMatrix4D result = new GLMatrix4D();

            for( byte i = 0; i < 16; ++i )
            {
                result.m[i] = mat.m[i] / val;
            }

            return result;
        }
Exemple #22
0
        /// <summary>
        /// Subtract one matrix from another
        /// </summary>
        /// <param name="one">Left Matrix</param>
        /// <param name="two">Right Matrix</param>
        /// <returns>New resulting matrix</returns>
        public static GLMatrix4D operator -( GLMatrix4D one, GLMatrix4D two)
        {
            GLMatrix4D result = new GLMatrix4D();

            for( byte i = 0; i < 16; ++i )
            {
                result.m[i] = one.m[i] - two.m[i];
            }

            return result;
        }
Exemple #23
0
        /// <summary>
        /// Get the matrix dot product, the most commonly used form of matrix multiplication
        /// </summary>
        /// <param name="one">Left Matrix</param>
        /// <param name="two">Right Matrix</param>
        /// <returns>New resulting matrix</returns>
        public static GLMatrix4D operator *( GLMatrix4D one, GLMatrix4D two )
        {
            GLMatrix4D ret = new GLMatrix4D();

            for( byte j = 0; j < 4; ++j )
            {
                ret.m[j] = one.m[j]*two.m[0]
                         + one.m[j+4]*two.m[1]
                         + one.m[j+8]*two.m[2]
                         + one.m[j+12]*two.m[3];

                ret.m[j+4] = one.m[j]*two.m[4]
                           + one.m[j+4]*two.m[5]
                           + one.m[j+8]*two.m[6]
                           + one.m[j+12]*two.m[7];

                ret.m[j+8] = one.m[j]*two.m[8]
                           + one.m[j+4]*two.m[9]
                           + one.m[j+8]*two.m[10]
                           + one.m[j+12]*two.m[11];

                ret.m[j+12] = one[j]*two.m[12]
                            + one[j+4]*two.m[13]
                            + one[j+8]*two.m[14]
                            + one[j+12]*two.m[15];
            }

            return ret;
        }
Exemple #24
0
        /// <summary>
        /// Copy a matrix
        /// </summary>
        /// <param name="mat">Source matrix to copy from</param>
        public GLMatrix4D(GLMatrix4D mat)
        {
            Buffer.BlockCopy( mat.m, 0, m, 0, Buffer.ByteLength( mat.m ) );

            return;
        }
Exemple #25
0
        /// <summary>
        /// Apply a XYZ rotation to this matrix
        /// </summary>
        /// <param name="angle">Angle of rotation around X axis</param>
        /// <param name="angle">Angle of rotation around Y axis</param>
        /// <param name="angle">Angle of rotation around Z axis</param>
        /// <returns>This matrix</returns>
        /// <remarks>Apply rotate[X,Y,Z,XYZ] specialisations by sebastien bloc</remarks>
        public GLMatrix4D ApplyRotateXYZ( double x,double y,double z )
        {
            GLMatrix4D temp = new GLMatrix4D();
            temp.LoadRotateX( x );
            Multiply3By3( temp );
            temp.loadRotateY( y );
            Multiply3By3( temp );
            temp.loadRotateZ( z );

            return Multiply3By3( temp );
        }
Exemple #26
0
        //!Return the transpose
        /// <summary>
        /// Get a transposed matrix
        /// </summary>
        /// <returns>A new matrix that is the transposed form of this</returns>
        public GLMatrix4D GetTranspose()
        {
            GLMatrix4D temp = new GLMatrix4D();

            for( int i = 0; i < 4; ++i)
            {
                for( int j = 0; j < 4; ++j)
                {
                    temp.m[j+i*4] = m[i+j*4];
                }
            }

            return temp;
        }
Exemple #27
0
        /// <summary>
        /// Apply a Z rotation to this matrix
        /// </summary>
        /// <param name="angle">Angle of rotation</param>
        /// <returns>This matrix</returns>
        /// <remarks>Apply rotate[X,Y,Z,XYZ] specialisations by sebastien bloc</remarks>
        public GLMatrix4D ApplyRotateZ( double angle )
        {
            GLMatrix4D temp = new GLMatrix4D();
            temp.loadRotateZ( angle );

            return Multiply3By3( temp );
        }
Exemple #28
0
        /// <summary>
        /// Apply the matrix dot product to this matrix
        /// </summary>
        /// <param name="mat">Right Side Matrix</param>
        /// <returns>This Matrix</returns>
        /// <remarks>unrolling by sebastien bloc</remarks>
        public GLMatrix4D Multiply3By3( GLMatrix4D mat )
        {
            GLMatrix4D temp = new GLMatrix4D( this );

            m[0] = temp.m[0]*mat.m[0]+temp.m[4]*mat.m[1]+temp.m[8]*mat.m[2];
            m[4] = temp.m[0]*mat.m[4]+temp.m[4]*mat.m[5]+temp.m[8]*mat.m[6];
            m[8] = temp.m[0]*mat.m[8]+temp.m[4]*mat.m[9]+temp.m[8]*mat.m[10];

            m[1] = temp.m[1]*mat.m[0]+temp.m[5]*mat.m[1]+temp.m[9]*mat.m[2];
            m[5] = temp.m[1]*mat.m[4]+temp.m[5]*mat.m[5]+temp.m[9]*mat.m[6];
            m[9] = temp.m[1]*mat.m[8]+temp.m[5]*mat.m[9]+temp.m[9]*mat.m[10];

            m[2] = temp.m[2]*mat.m[0]+temp.m[6]*mat.m[1]+temp.m[10]*mat.m[2];
            m[6] = temp.m[2]*mat.m[4]+temp.m[6]*mat.m[5]+temp.m[10]*mat.m[6];
            m[10] = temp.m[2]*mat.m[8]+temp.m[6]*mat.m[9]+temp.m[10]*mat.m[10];

            m[3] = temp.m[3]*mat.m[0]+temp.m[7]*mat.m[1]+temp.m[11]*mat.m[2];
            m[7] = temp.m[3]*mat.m[4]+temp.m[7]*mat.m[5]+temp.m[11]*mat.m[6];
            m[11] = temp.m[3]*mat.m[8]+temp.m[7]*mat.m[9]+temp.m[11]*mat.m[10];

            return this;
        }
Exemple #29
0
        /// <summary>
        /// Adjoint method inverse, constant time inversion implementation
        /// </summary>
        /// <returns>A new matrix that is inverse to this one</returns>
        public GLMatrix4D inverse()
        {
            GLMatrix4D ret = new GLMatrix4D(adjoint());

            double determinant = m[0]*ret[0] + m[1]*ret[4] + m[2]*ret[8] + m[3]*ret[12];

            //assert(determinant!=0 && "Singular matrix has no inverse");

            ret /= determinant;

            return ret;
        }
Exemple #30
0
        /// <summary>
        /// Copy a matrix
        /// </summary>
        /// <param name="mat">Source matrix to copy from</param>
        public GLMatrix4D(GLMatrix4D mat)
        {
            Buffer.BlockCopy(mat.m, 0, m, 0, Buffer.ByteLength(mat.m));

            return;
        }