Subversion Repositories AndroidProjects

package com.gebauz.Bauzoid.math;

public class Matrix4
{
        /* OpenGL Colum Major:
         *   m[0] m[4] m[8]  m[12]
         *   m[1] m[5] m[9]  m[13]
         *   m[2] m[6] m[10] m[14]
         *   m[3] m[7] m[11] m[15]
         */
        public float m11;
        public float m21;
        public float m31;
        public float m41;
        public float m12;
        public float m22;
        public float m32;
        public float m42;
        public float m13;
        public float m23;
        public float m33;
        public float m43;
        public float m14;
        public float m24;
        public float m34;
        public float m44;
       
        static public final int MATRIX_SIZE = 4;
       
        public Matrix4()
        {
        }
       
        public Matrix4(float[] m)
        {
                fromGLMatrix(m);               
        }
       
        public float get(int row, int col)
        {
                switch (row)
                {
                case 0:
                        switch (col)
                        {
                        case 0: return m11;
                        case 1: return m12;
                        case 2: return m13;
                        case 3: return m14;
                        }
                        break;
                case 1:
                        switch (col)
                        {
                        case 0: return m21;
                        case 1: return m22;
                        case 2: return m23;
                        case 3: return m24;
                        }
                        break;
                case 2:
                        switch (col)
                        {
                        case 0: return m31;
                        case 1: return m32;
                        case 2: return m33;
                        case 3: return m34;
                        }
                        break;
                case 3:
                        switch (col)
                        {
                        case 0: return m41;
                        case 1: return m42;
                        case 2: return m43;
                        case 3: return m44;
                        }
                        break;
                }
                // should never reach here -> TODO: assert
                return 0.0f;
        }
       
        public void set(int row, int col, float value)
        {
                switch (row)
                {
                case 0:
                        switch (col)
                        {
                        case 0:
                                m11 = value;
                                break;
                        case 1:
                                m12 = value;
                                break;
                        case 2:
                                m13 = value;
                                break;
                        case 3:
                                m14 = value;
                                break;
                        }
                        break;
                case 1:
                        switch (col)
                        {
                        case 0:
                                m21 = value;
                                break;
                        case 1:
                                m22 = value;
                                break;
                        case 2:
                                m23 = value;
                                break;
                        case 3:
                                m24 = value;
                                break;
                        }
                        break;
                case 2:
                        switch (col)
                        {
                        case 0:
                                m31 = value;
                                break;
                        case 1:
                                m32 = value;
                                break;
                        case 2:
                                m33 = value;
                                break;
                        case 3:
                                m34 = value;
                                break;
                        }
                        break;
                case 3:
                        switch (col)
                        {
                        case 0:
                                m41 = value;
                                break;
                        case 1:
                                m42 = value;
                                break;
                        case 2:
                                m43 = value;
                                break;
                        case 3:
                                m44 = value;
                                break;
                        }
                        break;
                }
        }
       
        public void zero()
        {
                m11 = 0.0f; m12 = 0.0f; m13 = 0.0f; m14 = 0.0f;        
                m21 = 0.0f; m22 = 0.0f; m23 = 0.0f; m24 = 0.0f;
                m31 = 0.0f; m32 = 0.0f; m33 = 0.0f; m34 = 0.0f;
                m41 = 0.0f; m42 = 0.0f; m43 = 0.0f; m44 = 0.0f;
        }
       
        public void identity()
        {
                zero();
                m11 = 1.0f; m22 = 1.0f; m33 = 1.0f; m44 = 1.0f;
        }
       
        public boolean equals(Matrix4 other)
        {
                return ((m11 == other.m11) && (m12 == other.m12) && (m13 == other.m13) && (m14 == other.m14) &&
                                (m21 == other.m21) && (m22 == other.m22) && (m23 == other.m23) && (m24 == other.m24) &&
                                (m31 == other.m31) && (m32 == other.m32) && (m33 == other.m33) && (m34 == other.m34) &&
                                (m41 == other.m41) && (m42 == other.m42) && (m43 == other.m43) && (m44 == other.m44));         
        }
       
        public boolean isSingular()
    {
        float determinant = getDeterminant();
        return ((float)Math.abs(determinant) < MathUtil.EPSILON);
    }
       
        public Matrix4 getTranspose()
        {
                Matrix4 result = new Matrix4();
                result.m11 = m11;
                result.m12 = m21;
                result.m13 = m31;
                result.m14 = m41;
                result.m21 = m12;
                result.m22 = m22;
                result.m23 = m32;
                result.m24 = m42;
                result.m31 = m13;
                result.m32 = m23;
                result.m33 = m33;
                result.m34 = m43;
                result.m41 = m14;
                result.m42 = m24;
                result.m43 = m34;
                result.m44 = m44;
                return result;
        }
       
        public float getDeterminant()
        {
        float result =
            m14 * m23 * m32 * m41 -
            m13 * m24 * m32 * m41 -
            m14 * m22 * m33 * m41 +
            m12 * m24 * m33 * m41 +
            m13 * m22 * m34 * m41 -
            m12 * m23 * m34 * m41 -
            m14 * m23 * m31 * m42 +
            m13 * m24 * m31 * m42 +
            m14 * m21 * m33 * m42 -
            m11 * m24 * m33 * m42 -
            m13 * m21 * m34 * m42 +
            m11 * m23 * m34 * m42 +
            m14 * m22 * m31 * m43 -
            m12 * m24 * m31 * m43 -
            m14 * m21 * m32 * m43 +
            m11 * m24 * m32 * m43 +
            m12 * m21 * m34 * m43 -
            m11 * m22 * m34 * m43 -
            m13 * m22 * m31 * m44 +
            m12 * m23 * m31 * m44 +
            m13 * m21 * m32 * m44 -
            m11 * m23 * m32 * m44 -
            m12 * m21 * m33 * m44 +
            m11 * m22 * m33 * m44;
        return result;
        }
       
        public Matrix4 getInverse()
        {
                Matrix4 result = new Matrix4();
               
                float determinant = getDeterminant();
                if (determinant == 0.0f)
                {
                        // singular matrix cannot be inverted
                        return this;
                }

        result.m11 = m23 * m34 * m42
                                 - m24 * m33 * m42
                                 + m24 * m32 * m43
                                 - m22 * m34 * m43
                                 - m23 * m32 * m44
                                 + m22 * m33 * m44;
        result.m12 = m14 * m33 * m42
                                 - m13 * m34 * m42
                                 - m14 * m32 * m43
                                 + m12 * m34 * m43
                                 + m13 * m32 * m44
                                 - m12 * m33 * m44;
        result.m13 = m13 * m24 * m42
                                 - m14 * m23 * m42
                                 + m14 * m22 * m43
                                 - m12 * m24 * m43
                                 - m13 * m22 * m44
                                 + m12 * m23 * m44;
        result.m14 = m14 * m23 * m32
                                 - m13 * m24 * m32
                                 - m14 * m22 * m33
                                 + m12 * m24 * m33
                                 + m13 * m22 * m34
                                 - m12 * m23 * m34;
        result.m21 = m24 * m33 * m41
                                 - m23 * m34 * m41
                                 - m24 * m31 * m43
                                 + m21 * m34 * m43
                                 + m23 * m31 * m44
                                 - m21 * m33 * m44;
        result.m22 = m13 * m34 * m41
                                 - m14 * m33 * m41
                                 + m14 * m31 * m43
                                 - m11 * m34 * m43
                                 - m13 * m31 * m44
                                 + m11 * m33 * m44;
        result.m23 = m14 * m23 * m41
                                 - m13 * m24 * m41
                                 - m14 * m21 * m43
                                 + m11 * m24 * m43
                                 + m13 * m21 * m44
                                 - m11 * m23 * m44;
        result.m24 = m13 * m24 * m31
                                 - m14 * m23 * m31
                                 + m14 * m21 * m33
                                 - m11 * m24 * m33
                                 - m13 * m21 * m34
                                 + m11 * m23 * m34;
        result.m31 = m22 * m34 * m41
                                 - m24 * m32 * m41
                                 + m24 * m31 * m42
                                 - m21 * m34 * m42
                                 - m22 * m31 * m44
                                 + m21 * m32 * m44;
        result.m32 = m14 * m32 * m41
                                 - m12 * m34 * m41
                                 - m14 * m31 * m42
                                 + m11 * m34 * m42
                                 + m12 * m31 * m44
                                 - m11 * m32 * m44;
        result.m33 = m12 * m24 * m41
                                 - m14 * m22 * m41
                                 + m14 * m21 * m42
                                 - m11 * m24 * m42
                                 - m12 * m21 * m44
                                 + m11 * m22 * m44;
        result.m34 = m14 * m22 * m31
                                 - m12 * m24 * m31
                                 - m14 * m21 * m32
                                 + m11 * m24 * m32
                                 + m12 * m21 * m34
                                 - m11 * m22 * m34;
        result.m41 = m23 * m32 * m41
                                 - m22 * m33 * m41
                                 - m23 * m31 * m42
                                 + m21 * m33 * m42
                                 + m22 * m31 * m43
                                 - m21 * m32 * m43;
        result.m42 = m12 * m33 * m41
                                 - m13 * m32 * m41
                                 + m13 * m31 * m42
                                 - m11 * m33 * m42
                                 - m12 * m31 * m43
                                 + m11 * m32 * m43;
        result.m43 = m13 * m22 * m41
                                 - m12 * m23 * m41
                                 - m13 * m21 * m42
                                 + m11 * m23 * m42
                                 + m12 * m21 * m43
                                 - m11 * m22 * m43;
        result.m44 = m12 * m23 * m31
                                 - m13 * m22 * m31
                                 + m13 * m21 * m32
                                 - m11 * m23 * m32
                                 - m12 * m21 * m33
                                 + m11 * m22 * m33;

                float multiply = 1.0f / determinant;
                result.m11 *= multiply;
                result.m21 *= multiply;
                result.m31 *= multiply;
                result.m41 *= multiply;
                result.m12 *= multiply;
                result.m22 *= multiply;
                result.m32 *= multiply;
                result.m42 *= multiply;
                result.m13 *= multiply;
                result.m23 *= multiply;
                result.m33 *= multiply;
                result.m43 *= multiply;
                result.m14 *= multiply;
                result.m24 *= multiply;
                result.m34 *= multiply;
                result.m44 *= multiply;

                return result;
        }

        public void copyTo(Matrix4 target)
        {
                target.m11 = m11; target.m12 = m12; target.m13 = m13; target.m14 = m14;
                target.m21 = m21; target.m22 = m22; target.m23 = m23; target.m24 = m24;
                target.m31 = m31; target.m32 = m32; target.m33 = m33; target.m34 = m34;
                target.m41 = m41; target.m42 = m42; target.m43 = m43; target.m44 = m44;
        }
       
        public void copyFrom(Matrix4 source)
        {
                m11 = source.m11; m12 = source.m12; m13 = source.m13; m14 = source.m14;
                m21 = source.m21; m22 = source.m22; m23 = source.m23; m24 = source.m24;
                m31 = source.m31; m32 = source.m32; m33 = source.m33; m34 = source.m34;
                m41 = source.m41; m42 = source.m42; m43 = source.m43; m44 = source.m44;
        }
       
        public void postMultiply(Matrix4 v)
        {
                multiply(this, this, v);
        }
       
        public void preMultiply(Matrix4 v)
        {
                multiply(this, v, this);
        }
       
        static public void multiply(Matrix4 result, Matrix4 a, Matrix4 b)
        {
        float result11 = a.m11 * b.m11 + a.m21 * b.m12 + a.m31 * b.m13 + a.m41 * b.m14;
        float result21 = a.m11 * b.m21 + a.m21 * b.m22 + a.m31 * b.m23 + a.m41 * b.m24;
        float result31 = a.m11 * b.m31 + a.m21 * b.m32 + a.m31 * b.m33 + a.m41 * b.m34;
        float result41 = a.m11 * b.m41 + a.m21 * b.m42 + a.m31 * b.m43 + a.m41 * b.m44;
        float result12 = a.m12 * b.m11 + a.m22 * b.m12 + a.m32 * b.m13 + a.m42 * b.m14;
        float result22 = a.m12 * b.m21 + a.m22 * b.m22 + a.m32 * b.m23 + a.m42 * b.m24;
        float result32 = a.m12 * b.m31 + a.m22 * b.m32 + a.m32 * b.m33 + a.m42 * b.m34;
        float result42 = a.m12 * b.m41 + a.m22 * b.m42 + a.m32 * b.m43 + a.m42 * b.m44;
        float result13 = a.m13 * b.m11 + a.m23 * b.m12 + a.m33 * b.m13 + a.m43 * b.m14;
        float result23 = a.m13 * b.m21 + a.m23 * b.m22 + a.m33 * b.m23 + a.m43 * b.m24;
                float result33 = a.m13 * b.m31 + a.m23 * b.m32 + a.m33 * b.m33 + a.m43 * b.m34;
                float result43 = a.m13 * b.m41 + a.m23 * b.m42 + a.m33 * b.m43 + a.m43 * b.m44;
                float result14 = a.m14 * b.m11 + a.m24 * b.m12 + a.m34 * b.m13 + a.m44 * b.m14;
                float result24 = a.m14 * b.m21 + a.m24 * b.m22 + a.m34 * b.m23 + a.m44 * b.m24;
                float result34 = a.m14 * b.m31 + a.m24 * b.m32 + a.m34 * b.m33 + a.m44 * b.m34;
                float result44 = a.m14 * b.m41 + a.m24 * b.m42 + a.m34 * b.m43 + a.m44 * b.m44;
                result.m11 = result11;
                result.m21 = result21;
                result.m31 = result31;
                result.m41 = result41;
                result.m12 = result12;
                result.m22 = result22;
                result.m32 = result32;
                result.m42 = result42;
                result.m13 = result13;
                result.m23 = result23;
                result.m33 = result33;
                result.m43 = result43;
                result.m14 = result14;
                result.m24 = result24;
                result.m34 = result34;
                result.m44 = result44;
        }
       
        static public Matrix4 multiply(Matrix4 a, Matrix4 b)
        {
                Matrix4 result = new Matrix4();
                multiply(result, a, b);
                return result;
        }
       
        static public Matrix4 createIdentity()
        {
                return createScale(1.0f, 1.0f, 1.0f);
        }
       
        static public Matrix4 createScale(float sx, float sy, float sz)
        {
                Matrix4 result = new Matrix4();
               
                result.m11 = sx;
                result.m22 = sy;
                result.m33 = sz;
                result.m44 = 1.0f;
               
                return result;         
        }
       
        static public Matrix4 createScale(Vector3 scale)
        {
                return createScale(scale.x, scale.y, scale.z);
        }
       
        static public Matrix4 createScale(float s)
        {
                return createScale(s, s, s);
        }
       
        static public Matrix4 createRotationX(float degrees)
        {
        float degreesrad = MathUtil.degToRad(degrees);
        float sinvalue = (float)Math.sin(degreesrad);
        float cosvalue = (float)Math.cos(degreesrad);

        Matrix4 matrix = createIdentity();
        matrix.m22 = cosvalue;
        matrix.m32 = -sinvalue;
        matrix.m23 = sinvalue;
        matrix.m33 = cosvalue;
        return matrix;
        }
       
        static public Matrix4 createRotationY(float degrees)
        {
        float degreesrad = MathUtil.degToRad(degrees);
        float sinvalue = (float)Math.sin(degreesrad);
        float cosvalue = (float)Math.cos(degreesrad);

        Matrix4 matrix = createIdentity();
        matrix.m11 = cosvalue;
        matrix.m31 = sinvalue;
        matrix.m13 = -sinvalue;
        matrix.m33 = cosvalue;
        return matrix;
        }
       
        static public Matrix4 createRotationZ(float degrees)
        {
        float degreesrad = MathUtil.degToRad(degrees);
        float sinvalue = (float)Math.sin(degreesrad);
        float cosvalue = (float)Math.cos(degreesrad);

        Matrix4 matrix = createIdentity();
        matrix.m11 = cosvalue;
        matrix.m21 = -sinvalue;
        matrix.m12 = sinvalue;
        matrix.m22 = cosvalue;
        return matrix;
        }
       
        static public Matrix4 createRotation(Vector3 axis, float degrees)
        {
        float radangle = MathUtil.degToRad(degrees);
        float radcos = (float)Math.cos(radangle);
        float radsin = (float)Math.sin(radangle);

        Matrix4 matrix = createIdentity();
        matrix.m11 = radcos + axis.x * axis.x * (1 - radcos);
        matrix.m21 = axis.z * radsin + axis.y * axis.x * (1 - radcos);
        matrix.m31 = -axis.y * radsin + axis.z * axis.x * (1 - radcos);
        matrix.m12 = -axis.z * radsin + axis.x * axis.y * (1 - radcos);
        matrix.m22 = radcos + axis.y * axis.y * (1 - radcos);
        matrix.m32 = axis.x * radsin + axis.z * axis.y * (1 - radcos);
        matrix.m13 = axis.y * radsin + axis.x * axis.z * (1 - radcos);
        matrix.m23 = -axis.x * radsin + axis.y * axis.z * (1 - radcos);
        matrix.m33 = radcos + axis.z * axis.z * (1 - radcos);
        matrix.m44 = 1.0f;
        return matrix;
        }
       
        static public Matrix4 createTranslation(float x, float y, float z)
        {
                Matrix4 result = new Matrix4();
        result.m11 = 1.0f;
        result.m21 = 0.0f;
        result.m31 = 0.0f;
        result.m41 = x;
        result.m12 = 0.0f;
        result.m22 = 1.0f;
        result.m32 = 0.0f;
        result.m42 = y;
        result.m13 = 0.0f;
        result.m23 = 0.0f;
        result.m33 = 1.0f;
        result.m43 = z;
        result.m14 = 0.0f;
        result.m24 = 0.0f;
        result.m34 = 0.0f;
        result.m44 = 1.0f;
        return result;
        }
       
        static public Matrix4 createTranslation(Vector3 translate)
        {
                return createTranslation(translate.x, translate.y, translate.z);
        }
       
        static public Matrix4 createFromVectors(Vector3 forward, Vector3 up, Vector3 right)
        {
        forward.normalize();
        up.normalize();
        right.normalize();
       
        Matrix4 result = createIdentity();
       
        result.m11 = right.x;
        result.m12 = right.y;
        result.m13 = right.z;
        result.m21 = up.x;
        result.m22 = up.y;
        result.m23 = up.z;
        result.m31 = -forward.x;
        result.m32 = -forward.y;
        result.m33 = -forward.z;
        result.m44 = 1.0f;
       
        return result;
        }
       
        static public Matrix4 createPerspective(float fovDegreesY, float aspect, float zNear, float zFar)
        {
/*              Matrix4 result = createIdentity();
               
                float radians = MathUtil.degToRad(fovDegreesY / 2.0f);
                float deltaZ = zFar - zNear;
                float sin = (float)Math.sin(radians);
               
                if ((deltaZ == 0) || (sin == 0) || (aspect == 0))
                {
                        return result;
                }
                float cotangent = (float)Math.cos(radians) / sin;
               
                result.m11 = cotangent / aspect;
                result.m22 = cotangent;
                result.m33 = -(zFar + zNear) / deltaZ;
                result.m43 = -1;
                result.m34 = -2 * zNear * zFar / deltaZ;
                result.m44 = 0;
               
                return result;*/

        float f = 1.0f / (float) Math.tan(fovDegreesY * (Math.PI / 360.0));
        float rangeReciprocal = 1.0f / (zNear - zFar);
               
                Matrix4 result = new Matrix4();
               
                result.m11 = f / aspect;
                result.m21 = 0.0f;
                result.m31 = 0.0f;
                result.m41 = 0.0f;
               
                result.m12 = 0.0f;
                result.m22 = f;
                result.m32 = 0.0f;
                result.m42 = 0.0f;
               
                result.m13 = 0.0f;
                result.m23 = 0.0f;
                result.m33 = (zFar + zNear) * rangeReciprocal;
                result.m43 = -1.0f;
               
                result.m14 = 0.0f;
                result.m24 = 0.0f;
                result.m34 = 2.0f * zFar * zNear * rangeReciprocal;
                result.m44 = 0.0f;
               
                return result;
               
               
                /*          float fovy, float aspect, float zNear, float zFar) {

                                float f = 1.0f / (float) Math.tan(fovy * (Math.PI / 360.0));
                                float rangeReciprocal = 1.0f / (zNear - zFar);
                       
                                m[offset + 0] = f / aspect;
                                m[offset + 1] = 0.0f;
                                m[offset + 2] = 0.0f;
                                m[offset + 3] = 0.0f;
                       
                                m[offset + 4] = 0.0f;
                                m[offset + 5] = f;
                                m[offset + 6] = 0.0f;
                                m[offset + 7] = 0.0f;
                       
                                m[offset + 8] = 0.0f;
                                m[offset + 9] = 0.0f;
                                m[offset + 10] = (zFar + zNear) * rangeReciprocal;
                                m[offset + 11] = -1.0f;
                       
                                m[offset + 12] = 0.0f;
                                m[offset + 13] = 0.0f;
                                m[offset + 14] = 2.0f * zFar * zNear * rangeReciprocal;
                                m[offset + 15] = 0.0f;*/
        }
       
        static public Matrix4 createFrustum(float left, float right, float bottom, float top, float near, float far)
        {
        if (left == right)
        {
            throw new IllegalArgumentException("left == right");
        }
        if (top == bottom)
        {
            throw new IllegalArgumentException("top == bottom");
        }
        if (near == far)
        {
            throw new IllegalArgumentException("near == far");
        }
        if (near <= 0.0f)
        {
            throw new IllegalArgumentException("near <= 0.0f");
        }
        if (far <= 0.0f)
        {
            throw new IllegalArgumentException("far <= 0.0f");
        }
       
        final float r_width  = 1.0f / (right - left);
        final float r_height = 1.0f / (top - bottom);
        final float r_depth  = 1.0f / (near - far);
        final float x = 2.0f * (near * r_width);
        final float y = 2.0f * (near * r_height);
        final float A = 2.0f * ((right + left) * r_width);
        final float B = (top + bottom) * r_height;
        final float C = (far + near) * r_depth;
        final float D = 2.0f * (far * near * r_depth);
       
        Matrix4 r = new Matrix4();
       
        r.m11 = x;
        r.m21 = 0.0f;
        r.m31 = 0.0f;
        r.m41 = 0.0f;
       
        r.m12 = 0.0f;
        r.m22 = y;
        r.m32 = 0.0f;
        r.m42 = 0.0f;
       
        r.m13 = A;
        r.m23 = B;
        r.m33 = C;
        r.m43 = -1.0f;
       
        r.m14 = 0.0f;
        r.m24 = 0.0f;
        r.m34 = D;
        r.m44 = 0.0f;
       
        return r;
       
/*              Matrix4 result = new Matrix4();
               
                if ((near <= 0.0f) ||
                        (far <= 0.0f) ||
                        (near == far) ||
                        (left == right) ||
                        (top == bottom))
                {
                        return result;
                }

                float x = (2.0f * near) / (right - left);
                float y = (2.0f * near) / (top - bottom);
                float a = (right + left) / (right - left);
                float b = (top + bottom) / (top - bottom);
                float c = -(far + near) / (far - near);
                float d = -(2.0f * far * near) / (far - near);
               
                result.m11 = x;    result.m21 = 0.0f; result.m31 = a;     result.m41 = 0.0f;
                result.m12 = 0.0f; result.m22 = y;    result.m32 = b;     result.m42 = 0.0f;
                result.m13 = 0.0f; result.m23 = 0.0f; result.m33 = c;     result.m43 = -1.0f;
                result.m14 = 0.0f; result.m24 = 0.0f; result.m34 = d; result.m44 = 0.0f;
               
                return result;*/
        }
               
        /*      m[0] = m11; m[1] = m21; m[2] = m31; m[3] = m41;
                m[4] = m12; m[5] = m22; m[6] = m32; m[7] = m42;
                m[8] = m13; m[9] = m23; m[10] = m33; m[11] = m43;
                m[12] = m14; m[13] = m24; m[14] = m34; m[15] = m44;*/
       

        static public Matrix4 createLookAt(float eyeX, float eyeY, float eyeZ, float centerX, float centerY, float centerZ, float upX, float upY, float upZ)
        {
        float fx = centerX - eyeX;
        float fy = centerY - eyeY;
        float fz = centerZ - eyeZ;

        // Normalize f
        float rlf = 1.0f / Vector3.length(fx, fy, fz);
        fx *= rlf;
        fy *= rlf;
        fz *= rlf;

        // compute s = f x up (x means "cross product")
        float sx = fy * upZ - fz * upY;
        float sy = fz * upX - fx * upZ;
        float sz = fx * upY - fy * upX;

        // and normalize s
        float rls = 1.0f / Vector3.length(sx, sy, sz);
        sx *= rls;
        sy *= rls;
        sz *= rls;

        // compute u = s x f
        float ux = sy * fz - sz * fy;
        float uy = sz * fx - sx * fz;
        float uz = sx * fy - sy * fx;
       
        Matrix4 r = new Matrix4();

        r.m11 = sx;
        r.m21 = ux;
        r.m31 = -fx;
        r.m41 = 0.0f;

        r.m12 = sy;
        r.m22 = uy;
        r.m32 = -fy;
        r.m42 = 0.0f;

        r.m13 = sz;
        r.m23 = uz;
        r.m33 = -fz;
        r.m43 = 0.0f;

        r.m14 = 0.0f;
        r.m24 = 0.0f;
        r.m34 = 0.0f;
        r.m44 = 1.0f;
       
        r.m14 = r.m11 * -eyeX + r.m12 * -eyeY + r.m13 * -eyeZ + r.m14;
        r.m24 = r.m21 * -eyeX + r.m22 * -eyeY + r.m23 * -eyeZ + r.m24;
        r.m34 = r.m31 * -eyeX + r.m32 * -eyeY + r.m33 * -eyeZ + r.m34;
        r.m44 = r.m41 * -eyeX + r.m42 * -eyeY + r.m43 * -eyeZ + r.m44;

        //translateM(rm, rmOffset, -eyeX, -eyeY, -eyeZ);
/*        for (int i = 0 ; i < 4 ; i++)
        {
            tm[12 + i] = m[i] * x + m[4 + i] * y + m[8 + i] * z + m[12 + i];
        }*/
               
                //return createLookAt(new Vector3(eyeX, eyeY, eyeZ), new Vector3(centerX, centerY, centerZ), new Vector3(upX, upY, upZ));
        return r;
        }
       
/*      static public Matrix4 createLookAt(Vector3 eye, Vector3 center, Vector3 up)
        {
                Vector3 forward = Vector3.subtract(center, eye);
                forward.normalize();

                // side = forward x up
                Vector3 side = Vector3.crossProduct(forward, up);
                side.normalize();
               
                // recalculate up = side x forward
                Vector3 up2 = Vector3.crossProduct(side, forward);
                //up2.normalize();      // maybe not needed?

        Matrix4 result = Matrix4.createIdentity();
                result.m11 = side.x;
                result.m12 = side.y;
                result.m13 = side.z;

                result.m21 = up.x;
                result.m22 = up.y;
                result.m23 = up.z;

                result.m31 = -forward.x;
                result.m32 = -forward.y;
                result.m33 = -forward.z;

                result.m14 = -Vector3.dotProduct(side, eye);
                result.m24 = -Vector3.dotProduct(up, eye);
                result.m34 = Vector3.dotProduct(forward, eye);
               
                return result;
        }*/
                                 

       
/*      void SetLookAt(HxVec3<T> eye, HxVec3<T> center, HxVec3<T> up)
        {
                HxVec3<T> forward;
                HxVec3<T> side;

        forward = center - eye;

                forward.Normalize();

                // side = forward x up
                side = CrossProduct(forward, up);
                side.Normalize();

                // recalculate up = side x forward
                up = CrossProduct(side, forward);
                //up.Normalize();       // maybe not needed?

        LoadIdentity();
                m[0] = side[0];
                m[4] = side[1];
                m[8] = side[2];

                m[1] = up[0];
                m[5] = up[1];
                m[9] = up[2];

                m[2] = -forward[0];
                m[6] = -forward[1];
                m[10] = -forward[2];

                m[12] = -DotProduct(side, eye);
                m[13] = -DotProduct(up, eye);
                m[14] = DotProduct(forward, eye);

        }      
 */
       
        public Vector3 transform(Vector3 vector)
        {
               
                return new Vector3(
                m11 * vector.x + m21 * vector.y + m31 * vector.z + m41,
                m12 * vector.x + m22 * vector.y + m32 * vector.z + m42,
                m13 * vector.x + m23 * vector.y + m33 * vector.z + m43);
        }
       
        public Vector4 transform(Vector4 vector)
        {
        return new Vector4(
                m11 * vector.x + m21 * vector.y + m31 * vector.z + m41 * vector.w,
                m12 * vector.x + m22 * vector.y + m32 * vector.z + m42 * vector.w,
                m13 * vector.x + m23 * vector.y + m33 * vector.z + m43 * vector.w,
                m14 * vector.x + m24 * vector.y + m34 * vector.z + m44 * vector.w);
        }
       
        static public void interpolate(Matrix4 result, Matrix4 a, Matrix4 b, float ratio)
        {
        result.m11 = a.m11 + (b.m11 - a.m11) * ratio;
        result.m21 = a.m21 + (b.m21 - a.m21) * ratio;
        result.m31 = a.m31 + (b.m31 - a.m31) * ratio;
        result.m41 = a.m41 + (b.m41 - a.m41) * ratio;
        result.m12 = a.m12 + (b.m12 - a.m12) * ratio;
        result.m22 = a.m22 + (b.m22 - a.m22) * ratio;
        result.m32 = a.m32 + (b.m32 - a.m32) * ratio;
        result.m42 = a.m42 + (b.m42 - a.m42) * ratio;
        result.m13 = a.m13 + (b.m13 - a.m13) * ratio;
        result.m23 = a.m23 + (b.m23 - a.m23) * ratio;
        result.m33 = a.m33 + (b.m33 - a.m33) * ratio;
        result.m43 = a.m43 + (b.m43 - a.m43) * ratio;
        result.m14 = a.m14 + (b.m14 - a.m14) * ratio;
        result.m24 = a.m24 + (b.m24 - a.m24) * ratio;
        result.m34 = a.m34 + (b.m34 - a.m34) * ratio;
        result.m44 = a.m44 + (b.m44 - a.m44) * ratio;
        }
       
        static public Matrix4 interpolate(Matrix4 a, Matrix4 b, float ratio)
        {
                Matrix4 result = createIdentity();
                interpolate(result, a, b, ratio);
                return result;
        }
       
        public Vector3 getForwardVector()
        {
                Vector3 forward = new Vector3(-m31, -m32, -m33);
        forward.normalize();
        return forward;
        }
       
        public Vector3 getUpVector()
        {
        Vector3 up = new Vector3(m21, m22, m23);
        up.normalize();
        return up;
        }
       
        public Vector3 getRightVector()
        {
        Vector3 right = new Vector3(m11, m12, m13);
        right.normalize();
        return right;
        }
       
        public float[] toGLMatrix()
        {
                float[] m = new float[16];
               
                m[0] = m11; m[1] = m21; m[2] = m31; m[3] = m41;
                m[4] = m12; m[5] = m22; m[6] = m32; m[7] = m42;
                m[8] = m13; m[9] = m23; m[10] = m33; m[11] = m43;
                m[12] = m14; m[13] = m24; m[14] = m34; m[15] = m44;
               
                return m;
        }
       
        public void fromGLMatrix(float[] m)
        {
                m11 = m[0]; m21 = m[1]; m31 = m[2]; m41 = m[3];
                m12 = m[4]; m22 = m[5]; m32 = m[6]; m42 = m[7];
                m13 = m[8]; m23 = m[9]; m33 = m[10]; m43 = m[11];
                m14 = m[12]; m24 = m[13]; m34 = m[14]; m44 = m[15];
        }      
       
}