OpenGL full mat4 lib

/*
    Vec.js required for some methods (pastebin.com/Hdxg8dxn)

    Please, if you're going to use it, could you put a link to my pastebin account and my e-mail (tutmes@gmail.com)?
    Thanks ;)
*/

window.Matrix = {};

Matrix.CreateScale = function(sX, sY, sZ)
{
    arguments.length == 1 && (sY = sZ = sX);

    return [
        sX,  0,  0, 0,
         0, sY,  0, 0,
         0,  0, sZ, 0,
         0,  0,  0, 1
    ];
};

Matrix.CreateTranslation = function(dX, dY, dZ)
{
    arguments.length == 1 && (dY = dZ = dX);

    return [
         1,  0,  0, 0,
         0,  1,  0, 0,
         0,  0,  1, 0,
        dX, dY, dZ, 1
    ];
};

Matrix.CreateRotationX = function(Ang)
{
    var Cos = Math.cos(Ang);
    var Sin = Math.sin(Ang);

    return [
        1,    0,   0, 0,
        0,  Cos, Sin, 0,
        0, -Sin, Cos, 0,
        0,    0,   0, 1
    ];
};

Matrix.CreateRotationY = function(Ang)
{
    var Cos = Math.cos(Ang);
    var Sin = Math.sin(Ang);

    return [
        Cos, 0, -Sin, 0,
          0, 1,    0, 0,
        Sin, 0,  Cos, 0,
          0, 0,    0, 1
    ];
};

Matrix.CreateRotationZ = function(Ang)
{
    var Cos = Math.cos(Ang);
    var Sin = Math.sin(Ang);

    return [
         Cos, Sin, 0, 0,
        -Sin, Cos, 0, 0,
           0,   0, 1, 0,
           0,   0, 0, 1
    ];
};

Matrix.Mul = function(M2, M1)
{
    var M3 = [];

    M3[0] = M1[0] * M2[0] + M1[1] * M2[4] + M1[2] *  M2[8] + M1[3] * M2[12];
    M3[1] = M1[0] * M2[1] + M1[1] * M2[5] + M1[2] *  M2[9] + M1[3] * M2[13];
    M3[2] = M1[0] * M2[2] + M1[1] * M2[6] + M1[2] * M2[10] + M1[3] * M2[14];
    M3[3] = M1[0] * M2[3] + M1[1] * M2[7] + M1[2] * M2[11] + M1[3] * M2[15];

    M3[4] = M1[4] * M2[0] + M1[5] * M2[4] + M1[6] *  M2[8] + M1[7] * M2[12];
    M3[5] = M1[4] * M2[1] + M1[5] * M2[5] + M1[6] *  M2[9] + M1[7] * M2[13];
    M3[6] = M1[4] * M2[2] + M1[5] * M2[6] + M1[6] * M2[10] + M1[7] * M2[14];
    M3[7] = M1[4] * M2[3] + M1[5] * M2[7] + M1[6] * M2[11] + M1[7] * M2[15];

    M3[8]  = M1[8] * M2[0] + M1[9] * M2[4] + M1[10] *  M2[8] + M1[11] * M2[12];
    M3[9]  = M1[8] * M2[1] + M1[9] * M2[5] + M1[10] *  M2[9] + M1[11] * M2[13];
    M3[10] = M1[8] * M2[2] + M1[9] * M2[6] + M1[10] * M2[10] + M1[11] * M2[14];
    M3[11] = M1[8] * M2[3] + M1[9] * M2[7] + M1[10] * M2[11] + M1[11] * M2[15];

    M3[12] = M1[12] * M2[0] + M1[13] * M2[4] + M1[14] *  M2[8] + M1[15] * M2[12];
    M3[13] = M1[12] * M2[1] + M1[13] * M2[5] + M1[14] *  M2[9] + M1[15] * M2[13];
    M3[14] = M1[12] * M2[2] + M1[13] * M2[6] + M1[14] * M2[10] + M1[15] * M2[14];
    M3[15] = M1[12] * M2[3] + M1[13] * M2[7] + M1[14] * M2[11] + M1[15] * M2[15];

    return M3;
};

Matrix.__defineGetter__("Identity", function()
{
    return [
        1, 0, 0, 0,
        0, 1, 0, 0,
        0, 0, 1, 0,
        0, 0, 0, 1
    ];
});

Matrix.Transpose = function(M)
{
    return [
        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]
    ];
};

Matrix.Transpose3 = function(M)
{
    return [
        M[0],  M[4],  M[8],  M[3],
        M[1],  M[5],  M[9],  M[7],
        M[2],  M[6],  M[10], M[11],
        M[12], M[13], M[14], M[15]
    ];
};

Matrix.CreateLookAt = function(Position, Target, Up) //Input params are all of Vector3 type.
{
    if(Position.Equals(Target))
        return Matrix.Identity;

    var zaxis = Position.Clone().Subtract(Target).Normalize();
    var xaxis = Up.Clone().Cross(zaxis).Normalize();
    var yaxis = zaxis.Clone().Cross(xaxis);

    var xdp = xaxis.Dot(Position);
    var ydp = yaxis.Dot(Position);
    var zdp = zaxis.Dot(Position);

    return [
        xaxis.X, yaxis.X, zaxis.X, 0,
        xaxis.Y, yaxis.Y, zaxis.Y, 0,
        xaxis.Z, yaxis.Z, zaxis.Z, 0,
           -xdp,    -ydp,    -zdp, 1
    ];
};

Matrix.CreatePerspectiveFieldOfView = function(Fov, AspectRatio, Near, Far)
{
    var yScale = 1 / Math.tan(Fov / 2);
    var xScale = yScale / AspectRatio;

    return [
        xScale,      0,                   0,  0,
             0, yScale,                   0,  0,
             0,      0,      Far/(Near-Far), -1,
             0,      0, Near*Far/(Near-Far),  0
    ];
};

Matrix.CreateOrthographic = function(Width, Height, Near, Far)
{
    return [
        2/Width,        0,            0,                0,
              0, 2/Height,            0,                0,
              0,        0, 1/(Far-Near), -Near/(Far-Near),
              0,        0,            0,                1
    ];
};

Matrix.Scale = function(M, S)
{
    var L = M.length;
    var Out = [];
    for(var I = 0; I < L; I++)
        Out[I] = M[I] * S;

    return Out;
};

Matrix.Determinant3 = function(M)
{
    var Forward = M[0] * M[4] * M[8] + M[1] * M[5] * M[6] + M[2] * M[3] * M[7];
    var Backwards = M[0] * M[5] * M[7] + M[1] * M[3] * M[8] + M[2] * M[4] * M[6];

    return Forward - Backwards;
};

Matrix.Reduce = function(M, x, y)
{
    var Out = [];
    for(var Y = 0; Y < 4; Y++)
    {
        if(Y == y)
            continue;

        for(var X = 0; X < 4; X++)
        {
            if(X == x)
                continue

            Out.push(M[Y * 4 + X]);
        }
    }

    return Out;
};

Matrix.Minor = function(M, X, Y)
{
    return Matrix.Determinant3(Matrix.Reduce(M, X, Y));
};

Matrix.Minors = function(M)
{
    var Minors = [];
    for(var Y = 0; Y < 4; Y++)
        for(var X = 0; X < 4; X++)
            Minors.push(Matrix.Minor(M, X, Y));

    return Minors;
};

Matrix.MinorsCofactors = function(M)
{
    var CoMinors = [];
    for(var Y = 0; Y < 4; Y++)
        for(var X = 0; X < 4; X++)
            CoMinors.push((Y + X) % 2 ? -Matrix.Minor(M, X, Y) : Matrix.Minor(M, X, Y));

    return CoMinors;
};

Matrix.Adjugate = function(M)
{
    return Matrix.Transpose(Matrix.MinorsCofactors(M));
};

Matrix.Determinant = function(M)
{
    var CoMinors = [
        Matrix.Minor(M, 0, 0),
        -Matrix.Minor(M, 1, 0),
        Matrix.Minor(M, 2, 0),
        -Matrix.Minor(M, 3, 0),
    ];

    return M[0] * CoMinors[0] + M[1] * CoMinors[1] + M[2] * CoMinors[2] + M[3] * CoMinors[3];
};

Matrix.Inverse = function(M)
{
    var CoMinors = Matrix.MinorsCofactors(M);
    var Det = M[0] * CoMinors[0] + M[1] * CoMinors[1] + M[2] * CoMinors[2] + M[3] * CoMinors[3];
    var Adj = Matrix.Transpose(CoMinors);

    return Matrix.Scale(Adj, 1 / Det);
};

Matrix.Forward = function(M)
{
    return new Vector3(-M[2], -M[6], -M[10]);
};

Matrix.Up = function(M)
{
    return new Vector3(M[1], M[5], M[9]);
};

Matrix.Right = function(M)
{
    return new Vector3(M[0], M[4], M[8]);
};