include/ui/mat4.h

/*
 * Copyright 2013 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef UI_MAT4_H_
#define UI_MAT4_H_

#include <ui/mat3.h>
#include <ui/quat.h>
#include <ui/TMatHelpers.h>
#include <ui/vec3.h>
#include <ui/vec4.h>

#include <stdint.h>
#include <sys/types.h>
#include <limits>

#define PURE __attribute__((pure))

namespace android {
// -------------------------------------------------------------------------------------
namespace details {

template<typename T>
class TQuaternion;

/**
 * A 4x4 column-major matrix class.
 *
 * Conceptually a 4x4 matrix is a an array of 4 column double4:
 *
 * mat4 m =
 *      \f$
 *      \left(
 *      \begin{array}{cccc}
 *      m[0] & m[1] & m[2] & m[3] \\
 *      \end{array}
 *      \right)
 *      \f$
 *      =
 *      \f$
 *      \left(
 *      \begin{array}{cccc}
 *      m[0][0] & m[1][0] & m[2][0] & m[3][0] \\
 *      m[0][1] & m[1][1] & m[2][1] & m[3][1] \\
 *      m[0][2] & m[1][2] & m[2][2] & m[3][2] \\
 *      m[0][3] & m[1][3] & m[2][3] & m[3][3] \\
 *      \end{array}
 *      \right)
 *      \f$
 *      =
 *      \f$
 *      \left(
 *      \begin{array}{cccc}
 *      m(0,0) & m(0,1) & m(0,2) & m(0,3) \\
 *      m(1,0) & m(1,1) & m(1,2) & m(1,3) \\
 *      m(2,0) & m(2,1) & m(2,2) & m(2,3) \\
 *      m(3,0) & m(3,1) & m(3,2) & m(3,3) \\
 *      \end{array}
 *      \right)
 *      \f$
 *
 * m[n] is the \f$ n^{th} \f$ column of the matrix and is a double4.
 *
 */
template <typename T>
class TMat44 :  public TVecUnaryOperators<TMat44, T>,
                public TVecComparisonOperators<TMat44, T>,
                public TVecAddOperators<TMat44, T>,
                public TMatProductOperators<TMat44, T>,
                public TMatSquareFunctions<TMat44, T>,
                public TMatTransform<TMat44, T>,
                public TMatHelpers<TMat44, T>,
                public TMatDebug<TMat44, T> {
public:
    enum no_init { NO_INIT };
    typedef T value_type;
    typedef T& reference;
    typedef T const& const_reference;
    typedef size_t size_type;
    typedef TVec4<T> col_type;
    typedef TVec4<T> row_type;

    static constexpr size_t COL_SIZE = col_type::SIZE;  // size of a column (i.e.: number of rows)
    static constexpr size_t ROW_SIZE = row_type::SIZE;  // size of a row (i.e.: number of columns)
    static constexpr size_t NUM_ROWS = COL_SIZE;
    static constexpr size_t NUM_COLS = ROW_SIZE;

private:
    /*
     *  <--  N columns  -->
     *
     *  a[0][0] a[1][0] a[2][0] ... a[N][0]    ^
     *  a[0][1] a[1][1] a[2][1] ... a[N][1]    |
     *  a[0][2] a[1][2] a[2][2] ... a[N][2]  M rows
     *  ...                                    |
     *  a[0][M] a[1][M] a[2][M] ... a[N][M]    v
     *
     *  COL_SIZE = M
     *  ROW_SIZE = N
     *  m[0] = [ a[0][0] a[0][1] a[0][2] ... a[0][M] ]
     */

    col_type m_value[NUM_COLS];

public:
    // array access
    inline constexpr col_type const& operator[](size_t column) const {
#if __cplusplus >= 201402L
        // only possible in C++0x14 with constexpr
        assert(column < NUM_COLS);
#endif
        return m_value[column];
    }

    inline col_type& operator[](size_t column) {
        assert(column < NUM_COLS);
        return m_value[column];
    }

    // -----------------------------------------------------------------------
    // we want the compiler generated versions for these...
    TMat44(const TMat44&) = default;
    ~TMat44() = default;
    TMat44& operator = (const TMat44&) = default;

    /*
     *  constructors
     */

    // leaves object uninitialized. use with caution.
    explicit
    constexpr TMat44(no_init)
            : m_value{ col_type(col_type::NO_INIT),
                       col_type(col_type::NO_INIT),
                       col_type(col_type::NO_INIT),
                       col_type(col_type::NO_INIT) } {}

    /** initialize to identity.
     *
     *      \f$
     *      \left(
     *      \begin{array}{cccc}
     *      1 & 0 & 0 & 0 \\
     *      0 & 1 & 0 & 0 \\
     *      0 & 0 & 1 & 0 \\
     *      0 & 0 & 0 & 1 \\
     *      \end{array}
     *      \right)
     *      \f$
     */
    TMat44();

    /** initialize to Identity*scalar.
     *
     *      \f$
     *      \left(
     *      \begin{array}{cccc}
     *      v & 0 & 0 & 0 \\
     *      0 & v & 0 & 0 \\
     *      0 & 0 & v & 0 \\
     *      0 & 0 & 0 & v \\
     *      \end{array}
     *      \right)
     *      \f$
     */
    template<typename U>
    explicit TMat44(U v);

    /** sets the diagonal to a vector.
     *
     *      \f$
     *      \left(
     *      \begin{array}{cccc}
     *      v[0] & 0 & 0 & 0 \\
     *      0 & v[1] & 0 & 0 \\
     *      0 & 0 & v[2] & 0 \\
     *      0 & 0 & 0 & v[3] \\
     *      \end{array}
     *      \right)
     *      \f$
     */
    template <typename U>
    explicit TMat44(const TVec4<U>& v);

    // construct from another matrix of the same size
    template <typename U>
    explicit TMat44(const TMat44<U>& rhs);

    /** construct from 4 column vectors.
     *
     *      \f$
     *      \left(
     *      \begin{array}{cccc}
     *      v0 & v1 & v2 & v3 \\
     *      \end{array}
     *      \right)
     *      \f$
     */
    template <typename A, typename B, typename C, typename D>
    TMat44(const TVec4<A>& v0, const TVec4<B>& v1, const TVec4<C>& v2, const TVec4<D>& v3);

    /** construct from 16 elements in column-major form.
     *
     *      \f$
     *      \left(
     *      \begin{array}{cccc}
     *      m[0][0] & m[1][0] & m[2][0] & m[3][0] \\
     *      m[0][1] & m[1][1] & m[2][1] & m[3][1] \\
     *      m[0][2] & m[1][2] & m[2][2] & m[3][2] \\
     *      m[0][3] & m[1][3] & m[2][3] & m[3][3] \\
     *      \end{array}
     *      \right)
     *      \f$
     */
    template <
        typename A, typename B, typename C, typename D,
        typename E, typename F, typename G, typename H,
        typename I, typename J, typename K, typename L,
        typename M, typename N, typename O, typename P>
    TMat44(A m00, B m01, C m02, D m03,
           E m10, F m11, G m12, H m13,
           I m20, J m21, K m22, L m23,
           M m30, N m31, O m32, P m33);

    /**
     * construct from a quaternion
     */
    template <typename U>
    explicit TMat44(const TQuaternion<U>& q);

    /**
     * construct from a C array in column major form.
     */
    template <typename U>
    explicit TMat44(U const* rawArray);

    /**
     * construct from a 3x3 matrix
     */
    template <typename U>
    explicit TMat44(const TMat33<U>& matrix);

    /**
     * construct from a 3x3 matrix and 3d translation
     */
    template <typename U, typename V>
    TMat44(const TMat33<U>& matrix, const TVec3<V>& translation);

    /**
     * construct from a 3x3 matrix and 4d last column.
     */
    template <typename U, typename V>
    TMat44(const TMat33<U>& matrix, const TVec4<V>& column3);

    /*
     *  helpers
     */

    static TMat44 ortho(T left, T right, T bottom, T top, T near, T far);

    static TMat44 frustum(T left, T right, T bottom, T top, T near, T far);

    enum class Fov {
        HORIZONTAL,
        VERTICAL
    };
    static TMat44 perspective(T fov, T aspect, T near, T far, Fov direction = Fov::VERTICAL);

    template <typename A, typename B, typename C>
    static TMat44 lookAt(const TVec3<A>& eye, const TVec3<B>& center, const TVec3<C>& up);

    template <typename A>
    static TVec3<A> project(const TMat44& projectionMatrix, TVec3<A> vertice) {
        TVec4<A> r = projectionMatrix * TVec4<A>{ vertice, 1 };
        return r.xyz / r.w;
    }

    template <typename A>
    static TVec4<A> project(const TMat44& projectionMatrix, TVec4<A> vertice) {
        vertice = projectionMatrix * vertice;
        return { vertice.xyz / vertice.w, 1 };
    }

    /**
     * Constructs a 3x3 matrix from the upper-left corner of this 4x4 matrix
     */
    inline constexpr TMat33<T> upperLeft() const {
        return TMat33<T>(m_value[0].xyz, m_value[1].xyz, m_value[2].xyz);
    }
};

// ----------------------------------------------------------------------------------------
// Constructors
// ----------------------------------------------------------------------------------------

// Since the matrix code could become pretty big quickly, we don't inline most
// operations.

template <typename T>
TMat44<T>::TMat44() {
    m_value[0] = col_type(1, 0, 0, 0);
    m_value[1] = col_type(0, 1, 0, 0);
    m_value[2] = col_type(0, 0, 1, 0);
    m_value[3] = col_type(0, 0, 0, 1);
}

template <typename T>
template <typename U>
TMat44<T>::TMat44(U v) {
    m_value[0] = col_type(v, 0, 0, 0);
    m_value[1] = col_type(0, v, 0, 0);
    m_value[2] = col_type(0, 0, v, 0);
    m_value[3] = col_type(0, 0, 0, v);
}

template<typename T>
template<typename U>
TMat44<T>::TMat44(const TVec4<U>& v) {
    m_value[0] = col_type(v.x, 0, 0, 0);
    m_value[1] = col_type(0, v.y, 0, 0);
    m_value[2] = col_type(0, 0, v.z, 0);
    m_value[3] = col_type(0, 0, 0, v.w);
}

// construct from 16 scalars
template<typename T>
template <
    typename A, typename B, typename C, typename D,
    typename E, typename F, typename G, typename H,
    typename I, typename J, typename K, typename L,
    typename M, typename N, typename O, typename P>
TMat44<T>::TMat44(A m00, B m01, C m02, D m03,
                  E m10, F m11, G m12, H m13,
                  I m20, J m21, K m22, L m23,
                  M m30, N m31, O m32, P m33) {
    m_value[0] = col_type(m00, m01, m02, m03);
    m_value[1] = col_type(m10, m11, m12, m13);
    m_value[2] = col_type(m20, m21, m22, m23);
    m_value[3] = col_type(m30, m31, m32, m33);
}

template <typename T>
template <typename U>
TMat44<T>::TMat44(const TMat44<U>& rhs) {
    for (size_t col = 0; col < NUM_COLS; ++col) {
        m_value[col] = col_type(rhs[col]);
    }
}

// Construct from 4 column vectors.
template <typename T>
template <typename A, typename B, typename C, typename D>
TMat44<T>::TMat44(const TVec4<A>& v0, const TVec4<B>& v1, const TVec4<C>& v2, const TVec4<D>& v3) {
    m_value[0] = col_type(v0);
    m_value[1] = col_type(v1);
    m_value[2] = col_type(v2);
    m_value[3] = col_type(v3);
}

// Construct from raw array, in column-major form.
template <typename T>
template <typename U>
TMat44<T>::TMat44(U const* rawArray) {
    for (size_t col = 0; col < NUM_COLS; ++col) {
        for (size_t row = 0; row < NUM_ROWS; ++row) {
            m_value[col][row] = *rawArray++;
        }
    }
}

template <typename T>
template <typename U>
TMat44<T>::TMat44(const TQuaternion<U>& q) {
    const U n = q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w;
    const U s = n > 0 ? 2/n : 0;
    const U x = s*q.x;
    const U y = s*q.y;
    const U z = s*q.z;
    const U xx = x*q.x;
    const U xy = x*q.y;
    const U xz = x*q.z;
    const U xw = x*q.w;
    const U yy = y*q.y;
    const U yz = y*q.z;
    const U yw = y*q.w;
    const U zz = z*q.z;
    const U zw = z*q.w;
    m_value[0] = col_type(1-yy-zz,    xy+zw,    xz-yw,   0);
    m_value[1] = col_type(  xy-zw,  1-xx-zz,    yz+xw,   0);  // NOLINT
    m_value[2] = col_type(  xz+yw,    yz-xw,  1-xx-yy,   0);  // NOLINT
    m_value[3] = col_type(      0,        0,        0,   1);  // NOLINT
}

template <typename T>
template <typename U>
TMat44<T>::TMat44(const TMat33<U>& m) {
    m_value[0] = col_type(m[0][0], m[0][1], m[0][2], 0);
    m_value[1] = col_type(m[1][0], m[1][1], m[1][2], 0);
    m_value[2] = col_type(m[2][0], m[2][1], m[2][2], 0);
    m_value[3] = col_type(      0,       0,       0, 1);  // NOLINT
}

template <typename T>
template <typename U, typename V>
TMat44<T>::TMat44(const TMat33<U>& m, const TVec3<V>& v) {
    m_value[0] = col_type(m[0][0], m[0][1], m[0][2], 0);
    m_value[1] = col_type(m[1][0], m[1][1], m[1][2], 0);
    m_value[2] = col_type(m[2][0], m[2][1], m[2][2], 0);
    m_value[3] = col_type(   v[0],    v[1],    v[2], 1);  // NOLINT
}

template <typename T>
template <typename U, typename V>
TMat44<T>::TMat44(const TMat33<U>& m, const TVec4<V>& v) {
    m_value[0] = col_type(m[0][0], m[0][1], m[0][2],    0);  // NOLINT
    m_value[1] = col_type(m[1][0], m[1][1], m[1][2],    0);  // NOLINT
    m_value[2] = col_type(m[2][0], m[2][1], m[2][2],    0);  // NOLINT
    m_value[3] = col_type(   v[0],    v[1],    v[2], v[3]);  // NOLINT
}

// ----------------------------------------------------------------------------------------
// Helpers
// ----------------------------------------------------------------------------------------

template <typename T>
TMat44<T> TMat44<T>::ortho(T left, T right, T bottom, T top, T near, T far) {
    TMat44<T> m;
    m[0][0] =  2 / (right - left);
    m[1][1] =  2 / (top   - bottom);
    m[2][2] = -2 / (far   - near);
    m[3][0] = -(right + left)   / (right - left);
    m[3][1] = -(top   + bottom) / (top   - bottom);
    m[3][2] = -(far   + near)   / (far   - near);
    return m;
}

template <typename T>
TMat44<T> TMat44<T>::frustum(T left, T right, T bottom, T top, T near, T far) {
    TMat44<T> m;
    m[0][0] =  (2 * near) / (right - left);
    m[1][1] =  (2 * near) / (top   - bottom);
    m[2][0] =  (right + left)   / (right - left);
    m[2][1] =  (top   + bottom) / (top   - bottom);
    m[2][2] = -(far   + near)   / (far   - near);
    m[2][3] = -1;
    m[3][2] = -(2 * far * near) / (far   - near);
    m[3][3] =  0;
    return m;
}

template <typename T>
TMat44<T> TMat44<T>::perspective(T fov, T aspect, T near, T far, TMat44::Fov direction) {
    T h;
    T w;

    if (direction == TMat44::Fov::VERTICAL) {
        h = std::tan(fov * M_PI / 360.0f) * near;
        w = h * aspect;
    } else {
        w = std::tan(fov * M_PI / 360.0f) * near;
        h = w / aspect;
    }
    return frustum(-w, w, -h, h, near, far);
}

/*
 * Returns a matrix representing the pose of a virtual camera looking towards -Z in its
 * local Y-up coordinate system. "eye" is where the camera is located, "center" is the points its
 * looking at and "up" defines where the Y axis of the camera's local coordinate system is.
 */
template <typename T>
template <typename A, typename B, typename C>
TMat44<T> TMat44<T>::lookAt(const TVec3<A>& eye, const TVec3<B>& center, const TVec3<C>& up) {
    TVec3<T> z_axis(normalize(center - eye));
    TVec3<T> norm_up(normalize(up));
    if (std::abs(dot(z_axis, norm_up)) > 0.999) {
        // Fix up vector if we're degenerate (looking straight up, basically)
        norm_up = { norm_up.z, norm_up.x, norm_up.y };
    }
    TVec3<T> x_axis(normalize(cross(z_axis, norm_up)));
    TVec3<T> y_axis(cross(x_axis, z_axis));
    return TMat44<T>(
            TVec4<T>(x_axis, 0),
            TVec4<T>(y_axis, 0),
            TVec4<T>(-z_axis, 0),
            TVec4<T>(eye, 1));
}

// ----------------------------------------------------------------------------------------
// Arithmetic operators outside of class
// ----------------------------------------------------------------------------------------

/* We use non-friend functions here to prevent the compiler from using
 * implicit conversions, for instance of a scalar to a vector. The result would
 * not be what the caller expects.
 *
 * Also note that the order of the arguments in the inner loop is important since
 * it determines the output type (only relevant when T != U).
 */

// matrix * column-vector, result is a vector of the same type than the input vector
template <typename T, typename U>
typename TMat44<T>::col_type PURE operator *(const TMat44<T>& lhs, const TVec4<U>& rhs) {
    // Result is initialized to zero.
    typename TMat44<T>::col_type result;
    for (size_t col = 0; col < TMat44<T>::NUM_COLS; ++col) {
        result += lhs[col] * rhs[col];
    }
    return result;
}

// mat44 * vec3, result is vec3( mat44 * {vec3, 1} )
template <typename T, typename U>
typename TMat44<T>::col_type PURE operator *(const TMat44<T>& lhs, const TVec3<U>& rhs) {
    return lhs * TVec4<U>{ rhs, 1 };
}


// row-vector * matrix, result is a vector of the same type than the input vector
template <typename T, typename U>
typename TMat44<U>::row_type PURE operator *(const TVec4<U>& lhs, const TMat44<T>& rhs) {
    typename TMat44<U>::row_type result(TMat44<U>::row_type::NO_INIT);
    for (size_t col = 0; col < TMat44<T>::NUM_COLS; ++col) {
        result[col] = dot(lhs, rhs[col]);
    }
    return result;
}

// matrix * scalar, result is a matrix of the same type than the input matrix
template <typename T, typename U>
constexpr typename std::enable_if<std::is_arithmetic<U>::value, TMat44<T>>::type PURE
operator *(TMat44<T> lhs, U rhs) {
    return lhs *= rhs;
}

// scalar * matrix, result is a matrix of the same type than the input matrix
template <typename T, typename U>
constexpr typename std::enable_if<std::is_arithmetic<U>::value, TMat44<T>>::type PURE
operator *(U lhs, const TMat44<T>& rhs) {
    return rhs * lhs;
}

// ----------------------------------------------------------------------------------------

/* FIXME: this should go into TMatSquareFunctions<> but for some reason
 * BASE<T>::col_type is not accessible from there (???)
 */
template<typename T>
typename TMat44<T>::col_type PURE diag(const TMat44<T>& m) {
    return matrix::diag(m);
}

} // namespace details

// ----------------------------------------------------------------------------------------

typedef details::TMat44<double> mat4d;
typedef details::TMat44<float> mat4;
typedef details::TMat44<float> mat4f;

// ----------------------------------------------------------------------------------------
}  // namespace android

#undef PURE

#endif  // UI_MAT4_H_