Esempio n. 1
0
        //
        // Resumen:
        //     Creates a rotation matrix.
        //
        // Parámetros:
        //   q:
        public static Xirtam4x4 Rotate(Quaternion q)
        {
            //Vector3 angles = q.eulerAngles * Mathf.Deg2Rad;
            //
            //Xirtam4x4 mX = identity;
            //mX.m11 = mX.m22 = Mathf.Cos(angles.x);
            //mX.m21 = Mathf.Sin(angles.x);
            //mX.m12 = -mX.m21;
            //
            //Xirtam4x4 mY = Xirtam4x4.identity;
            //mY.m00 = mY.m22 = Mathf.Cos(angles.y);
            //mY.m02 = Mathf.Sin(angles.y);
            //mY.m20 = -mY.m02;
            //
            //Xirtam4x4 mZ = Xirtam4x4.identity;
            //mZ.m00 = mZ.m11 = Mathf.Cos(angles.z);
            //mZ.m10 = Mathf.Sin(angles.z);
            //mZ.m01 = -mZ.m10;
            //
            //Xirtam4x4 m = mX * mY * mZ;
            Xirtam4x4 m = identity;

            m.m00 = 1f - 2f * (q.y * q.y) - 2f * (q.z * q.z);
            m.m01 = 2f * (q.x * q.y) - 2f * (q.z * q.w);
            m.m02 = 2f * (q.x * q.z) + 2f * (q.y * q.w);
            m.m10 = 2f * (q.x * q.y) + 2f * (q.z * q.w);
            m.m11 = 1f - 2f * (q.x * q.x) - 2f * (q.z * q.z);
            m.m12 = 2f * (q.y * q.z) - 2f * (q.x * q.w);
            m.m20 = 2f * (q.x * q.z) - 2f * (q.y * q.w);
            m.m21 = 2f * (q.y * q.z) + 2f * (q.x * q.w);
            m.m22 = 1f - 2f * (q.x * q.x) - 2f * (q.y * q.y);

            return(m);
        }
Esempio n. 2
0
        public static Xirtam4x4 operator *(Xirtam4x4 lhs, Xirtam4x4 rhs)
        {
            Xirtam4x4 m = identity;

            m.m00 = (lhs.m00 * rhs.m00) + (lhs.m01 * rhs.m10) + (lhs.m02 * rhs.m20) + (lhs.m03 * rhs.m30);
            m.m01 = (lhs.m00 * rhs.m01) + (lhs.m01 * rhs.m11) + (lhs.m02 * rhs.m21) + (lhs.m03 * rhs.m31);
            m.m02 = (lhs.m00 * rhs.m02) + (lhs.m01 * rhs.m12) + (lhs.m02 * rhs.m22) + (lhs.m03 * rhs.m32);
            m.m03 = (lhs.m00 * rhs.m03) + (lhs.m01 * rhs.m13) + (lhs.m02 * rhs.m23) + (lhs.m03 * rhs.m33);

            m.m10 = (lhs.m10 * rhs.m00) + (lhs.m11 * rhs.m10) + (lhs.m12 * rhs.m20) + (lhs.m13 * rhs.m30);
            m.m11 = (lhs.m10 * rhs.m01) + (lhs.m11 * rhs.m11) + (lhs.m12 * rhs.m21) + (lhs.m13 * rhs.m31);
            m.m12 = (lhs.m10 * rhs.m02) + (lhs.m11 * rhs.m12) + (lhs.m12 * rhs.m22) + (lhs.m13 * rhs.m32);
            m.m13 = (lhs.m10 * rhs.m03) + (lhs.m11 * rhs.m13) + (lhs.m12 * rhs.m23) + (lhs.m13 * rhs.m33);

            m.m20 = (lhs.m20 * rhs.m00) + (lhs.m21 * rhs.m10) + (lhs.m22 * rhs.m20) + (lhs.m23 * rhs.m30);
            m.m21 = (lhs.m20 * rhs.m01) + (lhs.m21 * rhs.m11) + (lhs.m22 * rhs.m21) + (lhs.m23 * rhs.m31);
            m.m22 = (lhs.m20 * rhs.m02) + (lhs.m21 * rhs.m12) + (lhs.m22 * rhs.m22) + (lhs.m23 * rhs.m32);
            m.m23 = (lhs.m20 * rhs.m03) + (lhs.m21 * rhs.m13) + (lhs.m22 * rhs.m23) + (lhs.m23 * rhs.m33);

            m.m30 = (lhs.m30 * rhs.m00) + (lhs.m31 * rhs.m10) + (lhs.m32 * rhs.m20) + (lhs.m33 * rhs.m30);
            m.m31 = (lhs.m30 * rhs.m01) + (lhs.m31 * rhs.m11) + (lhs.m32 * rhs.m21) + (lhs.m33 * rhs.m31);
            m.m32 = (lhs.m30 * rhs.m02) + (lhs.m31 * rhs.m12) + (lhs.m32 * rhs.m22) + (lhs.m33 * rhs.m32);
            m.m33 = (lhs.m30 * rhs.m03) + (lhs.m31 * rhs.m13) + (lhs.m32 * rhs.m23) + (lhs.m33 * rhs.m33);

            return(m);
        }
Esempio n. 3
0
        public static Xirtam4x4 TRS(Vector3 pos, Quaternion q, Vector3 s)
        {
            Xirtam4x4 mT = Translate(pos);
            Xirtam4x4 mR = Rotate(q);
            Xirtam4x4 mS = Scale(s);

            return(mT * mR * mS);
        }
Esempio n. 4
0
        public static Xirtam4x4 Translate(Vector3 vector)
        {
            Xirtam4x4 m = identity;

            m.m03 = vector.x;
            m.m13 = vector.y;
            m.m23 = vector.z;

            return(m);
        }
Esempio n. 5
0
        public static Xirtam4x4 Scale(Vector3 vector)
        {
            Xirtam4x4 m = identity;

            m.m00 = vector.x;
            m.m11 = vector.y;
            m.m22 = vector.z;

            return(m);
        }