/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qmatrix4x4.h"

#include <QtCore/qmath.h>

#include <QtCore/qvariant.h>

#include <QtGui/qmatrix.h>

#include <QtGui/qtransform.h>

QT_BEGIN_NAMESPACE

#ifndef QT_NO_MATRIX4X4

/*!

    \class QMatrix4x4

    \brief The QMatrix4x4 class represents a 4x4 transformation matrix in 3D space.

    \since 4.6

    \ingroup painting-3D

    \sa QVector3D, QGenericMatrix

*/

static const qreal inv_dist_to_plane = 1. / 1024.;

/*!

    \fn QMatrix4x4::QMatrix4x4()

    Constructs an identity matrix.

*/

/*!

    Constructs a matrix from the given 16 floating-point \a values.

    The contents of the array \a values is assumed to be in

    row-major order.

    If the matrix has a special type (identity, translate, scale, etc),

    the programmer should follow this constructor with a call to

    optimize() if they wish QMatrix4x4 to optimize further

    calls to translate(), scale(), etc.

    \sa copyDataTo(), optimize()

*/

QMatrix4x4::QMatrix4x4(const qreal *values)

{

    for (int row = 0; row < 4; ++row)

        for (int col = 0; col < 4; ++col)

            m[col][row] = values[row * 4 + col];

    flagBits = General;

}

/*!

    \fn QMatrix4x4::QMatrix4x4(qreal m11, qreal m12, qreal m13, qreal m14, qreal m21, qreal m22, qreal m23, qreal m24, qreal m31, qreal m32, qreal m33, qreal m34, qreal m41, qreal m42, qreal m43, qreal m44)

    Constructs a matrix from the 16 elements \a m11, \a m12, \a m13, \a m14,

    \a m21, \a m22, \a m23, \a m24, \a m31, \a m32, \a m33, \a m34,

    \a m41, \a m42, \a m43, and \a m44.  The elements are specified in

    row-major order.

    If the matrix has a special type (identity, translate, scale, etc),

    the programmer should follow this constructor with a call to

    optimize() if they wish QMatrix4x4 to optimize further

    calls to translate(), scale(), etc.

    \sa optimize()

*/

#if !defined(QT_NO_MEMBER_TEMPLATES) || defined(Q_QDOC)

/*!

    \fn QMatrix4x4::QMatrix4x4(const QGenericMatrix<N, M, qreal>& matrix)

    Constructs a 4x4 matrix from the left-most 4 columns and top-most

    4 rows of \a matrix.  If \a matrix has less than 4 columns or rows,

    the remaining elements are filled with elements from the identity

    matrix.

    \sa toGenericMatrix(), qGenericMatrixToMatrix4x4()

*/

/*!

    \fn QGenericMatrix<N, M, qreal> QMatrix4x4::toGenericMatrix() const

    Constructs a NxM generic matrix from the left-most N columns and

    top-most M rows of this 4x4 matrix.  If N or M is greater than 4,

    then the remaining elements are filled with elements from the

    identity matrix.

    \sa qGenericMatrixFromMatrix4x4()

*/

#endif

/*!

    \fn QMatrix4x4 qGenericMatrixToMatrix4x4(const QGenericMatrix<N, M, qreal>& matrix)

    \relates QMatrix4x4

    Returns a 4x4 matrix constructed from the left-most 4 columns and

    top-most 4 rows of \a matrix.  If \a matrix has less than 4 columns

    or rows, the remaining elements are filled with elements from the

    identity matrix.

    \sa qGenericMatrixFromMatrix4x4()

*/

/*!

    \fn QGenericMatrix<N, M, qreal> qGenericMatrixFromMatrix4x4(const QMatrix4x4& matrix)

    \relates QMatrix4x4

    Returns a NxM generic matrix constructed from the left-most N columns

    and top-most M rows of \a matrix.  If N or M is greater than 4,

    then the remaining elements are filled with elements from the

    identity matrix.

    \sa qGenericMatrixToMatrix4x4(), QMatrix4x4::toGenericMatrix()

*/

/*!

    \internal

*/

QMatrix4x4::QMatrix4x4(const qreal *values, int cols, int rows)

{

    for (int col = 0; col < 4; ++col) {

        for (int row = 0; row < 4; ++row) {

            if (col < cols && row < rows)

                m[col][row] = values[col * rows + row];

            else if (col == row)

                m[col][row] = 1.0f;

            else

                m[col][row] = 0.0f;

        }

    }

    flagBits = General;

}

/*!

    Constructs a 4x4 matrix from a conventional Qt 2D affine

    transformation \a matrix.

    If \a matrix has a special type (identity, translate, scale, etc),

    the programmer should follow this constructor with a call to

    optimize() if they wish QMatrix4x4 to optimize further

    calls to translate(), scale(), etc.

    \sa toAffine(), optimize()

*/

QMatrix4x4::QMatrix4x4(const QMatrix& matrix)

{

    m[0][0] = matrix.m11();

    m[0][1] = matrix.m12();

    m[0][2] = 0.0f;

    m[0][3] = 0.0f;

    m[1][0] = matrix.m21();

    m[1][1] = matrix.m22();

    m[1][2] = 0.0f;

    m[1][3] = 0.0f;

    m[2][0] = 0.0f;

    m[2][1] = 0.0f;

    m[2][2] = 1.0f;

    m[2][3] = 0.0f;

    m[3][0] = matrix.dx();

    m[3][1] = matrix.dy();

    m[3][2] = 0.0f;

    m[3][3] = 1.0f;

    flagBits = General;

}

/*!

    Constructs a 4x4 matrix from the conventional Qt 2D

    transformation matrix \a transform.

    If \a transform has a special type (identity, translate, scale, etc),

    the programmer should follow this constructor with a call to

    optimize() if they wish QMatrix4x4 to optimize further

    calls to translate(), scale(), etc.

    \sa toTransform(), optimize()

*/

QMatrix4x4::QMatrix4x4(const QTransform& transform)

{

    m[0][0] = transform.m11();

    m[0][1] = transform.m12();

    m[0][2] = 0.0f;

    m[0][3] = transform.m13();

    m[1][0] = transform.m21();

    m[1][1] = transform.m22();

    m[1][2] = 0.0f;

    m[1][3] = transform.m23();

    m[2][0] = 0.0f;

    m[2][1] = 0.0f;

    m[2][2] = 1.0f;

    m[2][3] = 0.0f;

    m[3][0] = transform.dx();

    m[3][1] = transform.dy();

    m[3][2] = 0.0f;

    m[3][3] = transform.m33();

    flagBits = General;

}

/*!

    \fn const qreal& QMatrix4x4::operator()(int row, int column) const

    Returns a constant reference to the element at position

    (\a row, \a column) in this matrix.

    \sa column(), row()

*/

/*!

    \fn qreal& QMatrix4x4::operator()(int row, int column)

    Returns a reference to the element at position (\a row, \a column)

    in this matrix so that the element can be assigned to.

    \sa optimize(), setColumn(), setRow()

*/

/*!

    \fn QVector4D QMatrix4x4::column(int index) const

    Returns the elements of column \a index as a 4D vector.

    \sa setColumn(), row()

*/

/*!

    \fn void QMatrix4x4::setColumn(int index, const QVector4D& value)

    Sets the elements of column \a index to the components of \a value.

    \sa column(), setRow()

*/

/*!

    \fn QVector4D QMatrix4x4::row(int index) const

    Returns the elements of row \a index as a 4D vector.

    \sa setRow(), column()

*/

/*!

    \fn void QMatrix4x4::setRow(int index, const QVector4D& value)

    Sets the elements of row \a index to the components of \a value.

    \sa row(), setColumn()

*/

/*!

    \fn bool QMatrix4x4::isIdentity() const

    Returns true if this matrix is the identity; false otherwise.

    \sa setToIdentity()

*/

/*!

    \fn void QMatrix4x4::setToIdentity()

    Sets this matrix to the identity.

    \sa isIdentity()

*/

/*!

    \fn void QMatrix4x4::fill(qreal value)

    Fills all elements of this matrx with \a value.

*/

// The 4x4 matrix inverse algorithm is based on that described at:

// http://www.j3d.org/matrix_faq/matrfaq_latest.html#Q24

// Some optimization has been done to avoid making copies of 3x3

// sub-matrices and to unroll the loops.

// Calculate the determinant of a 3x3 sub-matrix.

//     | A B C |

// M = | D E F |   det(M) = A * (EI - HF) - B * (DI - GF) + C * (DH - GE)

//     | G H I |

static inline qreal matrixDet3

    (const qreal m[4][4], int col0, int col1, int col2,

     int row0, int row1, int row2)

{

    return m[col0][row0] *

                (m[col1][row1] * m[col2][row2] -

                 m[col1][row2] * m[col2][row1]) -

           m[col1][row0] *

                (m[col0][row1] * m[col2][row2] -

                 m[col0][row2] * m[col2][row1]) +

           m[col2][row0] *

                (m[col0][row1] * m[col1][row2] -

                 m[col0][row2] * m[col1][row1]);

}

// Calculate the determinant of a 4x4 matrix.

static inline qreal matrixDet4(const qreal m[4][4])

{

    qreal det;

    det  = m[0][0] * matrixDet3(m, 1, 2, 3, 1, 2, 3);

    det -= m[1][0] * matrixDet3(m, 0, 2, 3, 1, 2, 3);

    det += m[2][0] * matrixDet3(m, 0, 1, 3, 1, 2, 3);

    det -= m[3][0] * matrixDet3(m, 0, 1, 2, 1, 2, 3);

    return det;

}

/*!

    Returns the determinant of this matrix.

*/

qreal QMatrix4x4::determinant() const

{

    return qreal(matrixDet4(m));

}

/*!

    Returns the inverse of this matrix.  Returns the identity if

    this matrix cannot be inverted; i.e. determinant() is zero.

    If \a invertible is not null, then true will be written to

    that location if the matrix can be inverted; false otherwise.

    If the matrix is recognized as the identity or an orthonormal

    matrix, then this function will quickly invert the matrix

    using optimized routines.

    \sa determinant(), normalMatrix()

*/

QMatrix4x4 QMatrix4x4::inverted(bool *invertible) const

{

    // Handle some of the easy cases first.

    if (flagBits == Identity) {

        if (invertible)

            *invertible = true;

        return QMatrix4x4();

    } else if (flagBits == Translation) {

        QMatrix4x4 inv;

        inv.m[3][0] = -m[3][0];

        inv.m[3][1] = -m[3][1];

        inv.m[3][2] = -m[3][2];

        inv.flagBits = Translation;

        if (invertible)

            *invertible = true;

        return inv;

    } else if (flagBits == Rotation || flagBits == (Rotation | Translation)) {

        if (invertible)

            *invertible = true;

        return orthonormalInverse();

    }

    QMatrix4x4 inv(1); // The "1" says to not load the identity.

    qreal det = matrixDet4(m);

    if (det == 0.0f) {

        if (invertible)

            *invertible = false;

        return QMatrix4x4();

    }

    det = 1.0f / det;

    inv.m[0][0] =  matrixDet3(m, 1, 2, 3, 1, 2, 3) * det;

    inv.m[0][1] = -matrixDet3(m, 0, 2, 3, 1, 2, 3) * det;

    inv.m[0][2] =  matrixDet3(m, 0, 1, 3, 1, 2, 3) * det;

    inv.m[0][3] = -matrixDet3(m, 0, 1, 2, 1, 2, 3) * det;

    inv.m[1][0] = -matrixDet3(m, 1, 2, 3, 0, 2, 3) * det;

    inv.m[1][1] =  matrixDet3(m, 0, 2, 3, 0, 2, 3) * det;

    inv.m[1][2] = -matrixDet3(m, 0, 1, 3, 0, 2, 3) * det;

    inv.m[1][3] =  matrixDet3(m, 0, 1, 2, 0, 2, 3) * det;

    inv.m[2][0] =  matrixDet3(m, 1, 2, 3, 0, 1, 3) * det;

    inv.m[2][1] = -matrixDet3(m, 0, 2, 3, 0, 1, 3) * det;

    inv.m[2][2] =  matrixDet3(m, 0, 1, 3, 0, 1, 3) * det;

    inv.m[2][3] = -matrixDet3(m, 0, 1, 2, 0, 1, 3) * det;

    inv.m[3][0] = -matrixDet3(m, 1, 2, 3, 0, 1, 2) * det;

    inv.m[3][1] =  matrixDet3(m, 0, 2, 3, 0, 1, 2) * det;

    inv.m[3][2] = -matrixDet3(m, 0, 1, 3, 0, 1, 2) * det;

    inv.m[3][3] =  matrixDet3(m, 0, 1, 2, 0, 1, 2) * det;

    if (invertible)

        *invertible = true;

    return inv;

}

/*!

    Returns the normal matrix corresponding to this 4x4 transformation.

    The normal matrix is the transpose of the inverse of the top-left

    3x3 part of this 4x4 matrix.  If the 3x3 sub-matrix is not invertible,

    this function returns the identity.

    \sa inverted()

*/

QMatrix3x3 QMatrix4x4::normalMatrix() const

{

    QMatrix3x3 inv;

    // Handle the simple cases first.

    if (flagBits == Identity || flagBits == Translation) {

        return inv;

    } else if (flagBits == Scale || flagBits == (Translation | Scale)) {

        if (m[0][0] == 0.0f || m[1][1] == 0.0f || m[2][2] == 0.0f)

            return inv;

        inv.data()[0] = 1.0f / m[0][0];

        inv.data()[4] = 1.0f / m[1][1];

        inv.data()[8] = 1.0f / m[2][2];

        return inv;

    }

    qreal det = matrixDet3(m, 0, 1, 2, 0, 1, 2);

    if (det == 0.0f)

        return inv;

    det = 1.0f / det;

    qreal *invm = inv.data();

    // Invert and transpose in a single step.

    invm[0 + 0 * 3] =  (m[1][1] * m[2][2] - m[2][1] * m[1][2]) * det;

    invm[1 + 0 * 3] = -(m[1][0] * m[2][2] - m[1][2] * m[2][0]) * det;

    invm[2 + 0 * 3] =  (m[1][0] * m[2][1] - m[1][1] * m[2][0]) * det;

    invm[0 + 1 * 3] = -(m[0][1] * m[2][2] - m[2][1] * m[0][2]) * det;

    invm[1 + 1 * 3] =  (m[0][0] * m[2][2] - m[0][2] * m[2][0]) * det;

    invm[2 + 1 * 3] = -(m[0][0] * m[2][1] - m[0][1] * m[2][0]) * det;

    invm[0 + 2 * 3] =  (m[0][1] * m[1][2] - m[0][2] * m[1][1]) * det;

    invm[1 + 2 * 3] = -(m[0][0] * m[1][2] - m[0][2] * m[1][0]) * det;

    invm[2 + 2 * 3] =  (m[0][0] * m[1][1] - m[1][0] * m[0][1]) * det;

    return inv;

}

/*!

    Returns this matrix, transposed about its diagonal.

*/

QMatrix4x4 QMatrix4x4::transposed() const

{

    QMatrix4x4 result(1); // The "1" says to not load the identity.

    for (int row = 0; row < 4; ++row) {

        for (int col = 0; col < 4; ++col) {

            result.m[col][row] = m[row][col];

        }

    }

    return result;

}

/*!

    \fn QMatrix4x4& QMatrix4x4::operator+=(const QMatrix4x4& other)

    Adds the contents of \a other to this matrix.

*/

/*!

    \fn QMatrix4x4& QMatrix4x4::operator-=(const QMatrix4x4& other)

    Subtracts the contents of \a other from this matrix.

*/

/*!

    \fn QMatrix4x4& QMatrix4x4::operator*=(const QMatrix4x4& other)

    Multiplies the contents of \a other by this matrix.

*/

/*!

    \fn QMatrix4x4& QMatrix4x4::operator*=(qreal factor)

    \overload

    Multiplies all elements of this matrix by \a factor.

*/

/*!

    \overload

    Divides all elements of this matrix by \a divisor.

*/

QMatrix4x4& QMatrix4x4::operator/=(qreal divisor)

{

    m[0][0] /= divisor;

    m[0][1] /= divisor;

    m[0][2] /= divisor;

    m[0][3] /= divisor;

    m[1][0] /= divisor;

    m[1][1] /= divisor;

    m[1][2] /= divisor;

    m[1][3] /= divisor;

    m[2][0] /= divisor;

    m[2][1] /= divisor;

    m[2][2] /= divisor;

    m[2][3] /= divisor;

    m[3][0] /= divisor;

    m[3][1] /= divisor;

    m[3][2] /= divisor;

    m[3][3] /= divisor;

    flagBits = General;

    return *this;

}

/*!