var MathLight = {};
MathLight.RADIANS_PER_DEGREE = Math.PI / 180;
MathLight.DEGREES_PER_RADIAN = 180 / Math.PI;
MathLight.Vector3 = function(e, t, i) {
    this.x = e || 0,
    this.y = t || 0,
    this.z = i || 0
};

MathLight.Matrix4 = function() {
    this.elements = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]),
    arguments.length > 0 && console.error("MathLight.Matrix4: the constructor no longer reads arguments. use .set() instead.")
};

MathLight.Matrix4.prototype = {
    identity: function() {
        return this.set(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1),
        this
    },
    copy: function(e) {
        return this.elements.set(e.elements),
        this
    },
    applyToVector3: function(e) {
        var t = e.x
            , i = e.y
            , n = e.z
            , r = this.elements;
        return e.x = r[0] * t + r[4] * i + r[8] * n + r[12],
        e.y = r[1] * t + r[5] * i + r[9] * n + r[13],
        e.z = r[2] * t + r[6] * i + r[10] * n + r[14],
        this
    },
    getInverse: function(e, t) {
        var i = this.elements
            , n = e.elements
            , r = n[0]
            , o = n[1]
            , a = n[2]
            , s = n[3]
            , l = n[4]
            , c = n[5]
            , h = n[6]
            , u = n[7]
            , d = n[8]
            , p = n[9]
            , f = n[10]
            , g = n[11]
            , m = n[12]
            , v = n[13]
            , A = n[14]
            , y = n[15]
            , C = p * A * u - v * f * u + v * h * g - c * A * g - p * h * y + c * f * y
            , I = m * f * u - d * A * u - m * h * g + l * A * g + d * h * y - l * f * y
            , E = d * v * u - m * p * u + m * c * g - l * v * g - d * c * y + l * p * y
            , b = m * p * h - d * v * h - m * c * f + l * v * f + d * c * A - l * p * A
            , w = r * C + o * I + a * E + s * b;
        if (0 === w) {
            var _ = "MathLight.Matrix4.getInverse(): can't invert matrix, determinant is 0";
            if (t)
                throw new Error(_);
            return console.warn(_),
            this.identity()
        }
        var T = 1 / w;
        return i[0] = C * T,
        i[1] = (v * f * s - p * A * s - v * a * g + o * A * g + p * a * y - o * f * y) * T,
        i[2] = (c * A * s - v * h * s + v * a * u - o * A * u - c * a * y + o * h * y) * T,
        i[3] = (p * h * s - c * f * s - p * a * u + o * f * u + c * a * g - o * h * g) * T,
        i[4] = I * T,
        i[5] = (d * A * s - m * f * s + m * a * g - r * A * g - d * a * y + r * f * y) * T,
        i[6] = (m * h * s - l * A * s - m * a * u + r * A * u + l * a * y - r * h * y) * T,
        i[7] = (l * f * s - d * h * s + d * a * u - r * f * u - l * a * g + r * h * g) * T,
        i[8] = E * T,
        i[9] = (m * p * s - d * v * s - m * o * g + r * v * g + d * o * y - r * p * y) * T,
        i[10] = (l * v * s - m * c * s + m * o * u - r * v * u - l * o * y + r * c * y) * T,
        i[11] = (d * c * s - l * p * s - d * o * u + r * p * u + l * o * g - r * c * g) * T,
        i[12] = b * T,
        i[13] = (d * v * a - m * p * a + m * o * f - r * v * f - d * o * A + r * p * A) * T,
        i[14] = (m * c * a - l * v * a - m * o * h + r * v * h + l * o * A - r * c * A) * T,
        i[15] = (l * p * a - d * c * a + d * o * h - r * p * h - l * o * f + r * c * f) * T,
        this
    },
    makeRotationFromQuaternion: function(e) {
        var t = this.elements
            , i = e.x
            , n = e.y
            , r = e.z
            , o = e.w
            , a = i + i
            , s = n + n
            , l = r + r
            , c = i * a
            , h = i * s
            , u = i * l
            , d = n * s
            , p = n * l
            , f = r * l
            , g = o * a
            , m = o * s
            , v = o * l;
        return t[0] = 1 - (d + f),
        t[4] = h - v,
        t[8] = u + m,
        t[1] = h + v,
        t[5] = 1 - (c + f),
        t[9] = p - g,
        t[2] = u - m,
        t[6] = p + g,
        t[10] = 1 - (c + d),
        t[3] = 0,
        t[7] = 0,
        t[11] = 0,
        t[12] = 0,
        t[13] = 0,
        t[14] = 0,
        t[15] = 1,
        this
    }
};

MathLight.Quaternion = function(e, t, i, n) {
    this._x = e || 0,
    this._y = t || 0,
    this._z = i || 0,
    this._w = void 0 !== n ? n : 1
};

MathLight.Quaternion.prototype = {
    get x() {
        return this._x
    },
    set x(e) {
        this._x = e
    },
    get y() {
        return this._y
    },
    set y(e) {
        this._y = e
    },
    get z() {
        return this._z
    },
    set z(e) {
        this._z = e
    },
    get w() {
        return this._w
    },
    set w(e) {
        this._w = e
    },
    copy: function(e) {
        this._x = e.x,
        this._y = e.y,
        this._z = e.z,
        this._w = e.w
    },
    inverse: function() {
        return this.conjugate().normalize()
    },
    conjugate: function() {
        return this._x *= -1,
        this._y *= -1,
        this._z *= -1,
        this
    },
    length: function() {
        return Math.sqrt(this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w)
    },
    normalize: function() {
        var e = this.length();
        return 0 === e ? (this._x = 0,
        this._y = 0,
        this._z = 0,
        this._w = 1) : (e = 1 / e,
        this._x = this._x * e,
        this._y = this._y * e,
        this._z = this._z * e,
        this._w = this._w * e),
        this
    },
    setFromAxisAngle: function(e, t) {
        var i = t / 2
            , n = Math.sin(i);
        return this._x = e.x * n,
        this._y = e.y * n,
        this._z = e.z * n,
        this._w = Math.cos(i),
        this
    },
    setFromUnitVectors: function() {
        var e, t, i = 1e-6;
        return function(n, o) {
            return void 0 === e && (e = new MathLight.Vector3),
            t = MathLight.dot(n, o) + 1,
            t < i ? (t = 0,
            Math.abs(n.x) > Math.abs(n.z) ? MathLight.setVector(e, -n.y, n.x, 0) : MathLight.setVector(e, 0, -n.z, n.y)) : MathLight.cross(n, o, e),
            this._x = e.x,
            this._y = e.y,
            this._z = e.z,
            this._w = t,
            this.normalize()
        }
    }(),
    multiply: function(e) {
        return this.multiplyQuaternions(this, e)
    },
    premultiply: function(e) {
        return this.multiplyQuaternions(e, this)
    },
    multiplyQuaternions: function(e, t) {
        var i = e._x
            , n = e._y
            , r = e._z
            , o = e._w
            , a = t._x
            , s = t._y
            , l = t._z
            , c = t._w;
        return this._x = i * c + o * a + n * l - r * s,
        this._y = n * c + o * s + r * a - i * l,
        this._z = r * c + o * l + i * s - n * a,
        this._w = o * c - i * a - n * s - r * l,
        this
    }
};

MathLight.convertWorkshopVector = function(e) {
    return new MathLight.Vector3(-e.x,e.y,e.z)
};

MathLight.convertWorkshopQuaternion = function(e) {
    return new MathLight.Quaternion(-e.x,e.y,e.z,-e.w).multiply(new MathLight.Quaternion(Math.sqrt(2) / 2,Math.sqrt(2) / 2,0,0))
};

MathLight.convertWorkshopOrthoZoom = function(e) {
	//return e === -1 ? -1 : e / 16 * ($('#player').width() / $('#player').height()) / n.workshopApsect
	return e === -1 ? -1 : e  * ($("#player").width() / $("#player").height())  ;
};

MathLight.convertWorkshopPanoramaQuaternion = function(e) {
    return new MathLight.Quaternion(e.x,-e.y,-e.z,e.w).normalize().multiply((new MathLight.Quaternion).setFromAxisAngle(new MathLight.Vector3(0,1,0), 270 * MathLight.RADIANS_PER_DEGREE))
};

MathLight.normalize = function(e) {
    var t = e.x * e.x + e.y * e.y + e.z * e.z
        , i = Math.sqrt(t);
    e.x /= i,
    e.y /= i,
    e.z /= i
};

MathLight.dot = function(e, t) {
    return e.x * t.x + e.y * t.y + e.z * t.z
};

MathLight.cross = function(e, t, i) {
    var n = e.x
        , r = e.y
        , o = e.z;
    i.x = r * t.z - o * t.y,
    i.y = o * t.x - n * t.z,
    i.z = n * t.y - r * t.x
};

MathLight.setVector = function(e, t, i, n) {
    e.x = t,
    e.y = i,
    e.z = n
};

MathLight.copyVector = function(e, t) {
    t.x = e.x,
    t.y = e.y,
    t.z = e.z
};

MathLight.addVector = function(e, t) {
    e.x += t.x,
    e.y += t.y,
    e.z += t.z
};

MathLight.subVector = function(e, t) {
    e.x -= t.x,
    e.y -= t.y,
    e.z -= t.z
};

MathLight.applyQuaternionToVector = function(e, t) {
    var i = t.x
        , n = t.y
        , r = t.z
        , o = e.x
        , a = e.y
        , s = e.z
        , l = e.w
        , c = l * i + a * r - s * n
        , h = l * n + s * i - o * r
        , u = l * r + o * n - a * i
        , d = -o * i - a * n - s * r;
    t.x = c * l + d * -o + h * -s - u * -a,
    t.y = h * l + d * -a + u * -o - c * -s,
    t.z = u * l + d * -s + c * -a - h * -o
};

MathLight.angleBetweenVectors = function(e, t) {
    return Math.acos(MathLight.dot(e, t))
};



export default MathLight