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

**

** All rights reserved.

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

**

** This file is part of the test suite 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 <QtTest/QtTest>

#include <QtCore/qmath.h>

#include <QtGui/qmatrix4x4.h>

class tst_QMatrixNxN : public QObject

{

    Q_OBJECT

public:

    tst_QMatrixNxN() {}

    ~tst_QMatrixNxN() {}

private slots:

    void create2x2();

    void create3x3();

    void create4x4();

    void create4x3();

    void isIdentity2x2();

    void isIdentity3x3();

    void isIdentity4x4();

    void isIdentity4x3();

    void compare2x2();

    void compare3x3();

    void compare4x4();

    void compare4x3();

    void transposed2x2();

    void transposed3x3();

    void transposed4x4();

    void transposed4x3();

    void add2x2_data();

    void add2x2();

    void add3x3_data();

    void add3x3();

    void add4x4_data();

    void add4x4();

    void add4x3_data();

    void add4x3();

    void subtract2x2_data();

    void subtract2x2();

    void subtract3x3_data();

    void subtract3x3();

    void subtract4x4_data();

    void subtract4x4();

    void subtract4x3_data();

    void subtract4x3();

    void multiply2x2_data();

    void multiply2x2();

    void multiply3x3_data();

    void multiply3x3();

    void multiply4x4_data();

    void multiply4x4();

    void multiply4x3_data();

    void multiply4x3();

    void multiplyFactor2x2_data();

    void multiplyFactor2x2();

    void multiplyFactor3x3_data();

    void multiplyFactor3x3();

    void multiplyFactor4x4_data();

    void multiplyFactor4x4();

    void multiplyFactor4x3_data();

    void multiplyFactor4x3();

    void divideFactor2x2_data();

    void divideFactor2x2();

    void divideFactor3x3_data();

    void divideFactor3x3();

    void divideFactor4x4_data();

    void divideFactor4x4();

    void divideFactor4x3_data();

    void divideFactor4x3();

    void negate2x2_data();

    void negate2x2();

    void negate3x3_data();

    void negate3x3();

    void negate4x4_data();

    void negate4x4();

    void negate4x3_data();

    void negate4x3();

    void inverted4x4_data();

    void inverted4x4();

    void orthonormalInverse4x4();

    void scale4x4_data();

    void scale4x4();

    void translate4x4_data();

    void translate4x4();

    void rotate4x4_data();

    void rotate4x4();

    void normalMatrix_data();

    void normalMatrix();

    void optimizedTransforms();

    void ortho();

    void frustum();

    void perspective();

    void flipCoordinates();

    void convertGeneric();

    void optimize_data();

    void optimize();

    void columnsAndRows();

    void convertQMatrix();

    void convertQTransform();

    void fill();

    void mapRect_data();

    void mapRect();

    void mapVector_data();

    void mapVector();

    void properties();

    void metaTypes();

private:

    static void setMatrix(QMatrix2x2& m, const qreal *values);

    static void setMatrixDirect(QMatrix2x2& m, const qreal *values);

    static bool isSame(const QMatrix2x2& m, const qreal *values);

    static bool isIdentity(const QMatrix2x2& m);

    static void setMatrix(QMatrix3x3& m, const qreal *values);

    static void setMatrixDirect(QMatrix3x3& m, const qreal *values);

    static bool isSame(const QMatrix3x3& m, const qreal *values);

    static bool isIdentity(const QMatrix3x3& m);

    static void setMatrix(QMatrix4x4& m, const qreal *values);

    static void setMatrixDirect(QMatrix4x4& m, const qreal *values);

    static bool isSame(const QMatrix4x4& m, const qreal *values);

    static bool isIdentity(const QMatrix4x4& m);

    static void setMatrix(QMatrix4x3& m, const qreal *values);

    static void setMatrixDirect(QMatrix4x3& m, const qreal *values);

    static bool isSame(const QMatrix4x3& m, const qreal *values);

    static bool isIdentity(const QMatrix4x3& m);

};

static const qreal nullValues2[] =

    {0.0f, 0.0f,

     0.0f, 0.0f};

static qreal const identityValues2[16] =

    {1.0f, 0.0f,

     0.0f, 1.0f};

static const qreal doubleIdentity2[] =

    {2.0f, 0.0f,

     0.0f, 2.0f};

static qreal const uniqueValues2[16] =

    {1.0f, 2.0f,

     5.0f, 6.0f};

static qreal const transposedValues2[16] =

    {1.0f, 5.0f,

     2.0f, 6.0f};

static const qreal nullValues3[] =

    {0.0f, 0.0f, 0.0f,

     0.0f, 0.0f, 0.0f,

     0.0f, 0.0f, 0.0f};

static qreal const identityValues3[16] =

    {1.0f, 0.0f, 0.0f,

     0.0f, 1.0f, 0.0f,

     0.0f, 0.0f, 1.0f};

static const qreal doubleIdentity3[] =

    {2.0f, 0.0f, 0.0f,

     0.0f, 2.0f, 0.0f,

     0.0f, 0.0f, 2.0f};

static qreal const uniqueValues3[16] =

    {1.0f, 2.0f, 3.0f,

     5.0f, 6.0f, 7.0f,

     9.0f, 10.0f, 11.0f};

static qreal const transposedValues3[16] =

    {1.0f, 5.0f, 9.0f,

     2.0f, 6.0f, 10.0f,

     3.0f, 7.0f, 11.0f};

static const qreal nullValues4[] =

    {0.0f, 0.0f, 0.0f, 0.0f,

     0.0f, 0.0f, 0.0f, 0.0f,

     0.0f, 0.0f, 0.0f, 0.0f,

     0.0f, 0.0f, 0.0f, 0.0f};

static qreal const identityValues4[16] =

    {1.0f, 0.0f, 0.0f, 0.0f,

     0.0f, 1.0f, 0.0f, 0.0f,

     0.0f, 0.0f, 1.0f, 0.0f,

     0.0f, 0.0f, 0.0f, 1.0f};

static const qreal doubleIdentity4[] =

    {2.0f, 0.0f, 0.0f, 0.0f,

     0.0f, 2.0f, 0.0f, 0.0f,

     0.0f, 0.0f, 2.0f, 0.0f,

     0.0f, 0.0f, 0.0f, 2.0f};

static qreal const uniqueValues4[16] =

    {1.0f, 2.0f, 3.0f, 4.0f,

     5.0f, 6.0f, 7.0f, 8.0f,

     9.0f, 10.0f, 11.0f, 12.0f,

     13.0f, 14.0f, 15.0f, 16.0f};

static qreal const transposedValues4[16] =

    {1.0f, 5.0f, 9.0f, 13.0f,

     2.0f, 6.0f, 10.0f, 14.0f,

     3.0f, 7.0f, 11.0f, 15.0f,

     4.0f, 8.0f, 12.0f, 16.0f};

static const qreal nullValues4x3[] =

    {0.0f, 0.0f, 0.0f, 0.0f,

     0.0f, 0.0f, 0.0f, 0.0f,

     0.0f, 0.0f, 0.0f, 0.0f};

static qreal const identityValues4x3[12] =

    {1.0f, 0.0f, 0.0f, 0.0f,

     0.0f, 1.0f, 0.0f, 0.0f,

     0.0f, 0.0f, 1.0f, 0.0f};

static qreal const doubleIdentity4x3[12] =

    {2.0f, 0.0f, 0.0f, 0.0f,

     0.0f, 2.0f, 0.0f, 0.0f,

     0.0f, 0.0f, 2.0f, 0.0f};

static qreal const uniqueValues4x3[12] =

    {1.0f, 2.0f, 3.0f, 4.0f,

     5.0f, 6.0f, 7.0f, 8.0f,

     9.0f, 10.0f, 11.0f, 12.0f};

static qreal const transposedValues3x4[12] =

    {1.0f, 5.0f, 9.0f,

     2.0f, 6.0f, 10.0f,

     3.0f, 7.0f, 11.0f,

     4.0f, 8.0f, 12.0f};

// Set a matrix to a specified array of values, which are assumed

// to be in row-major order.  This sets the values using floating-point.

void tst_QMatrixNxN::setMatrix(QMatrix2x2& m, const qreal *values)

{

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

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

            m(row, col) = values[row * 2 + col];

}

void tst_QMatrixNxN::setMatrix(QMatrix3x3& m, const qreal *values)

{

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

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

            m(row, col) = values[row * 3 + col];

}

void tst_QMatrixNxN::setMatrix(QMatrix4x4& m, const qreal *values)

{

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

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

            m(row, col) = values[row * 4 + col];

}

void tst_QMatrixNxN::setMatrix(QMatrix4x3& m, const qreal *values)

{

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

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

            m(row, col) = values[row * 4 + col];

}

// Set a matrix to a specified array of values, which are assumed

// to be in row-major order.  This sets the values directly into

// the internal data() array.

void tst_QMatrixNxN::setMatrixDirect(QMatrix2x2& m, const qreal *values)

{

    qreal *data = m.data();

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

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

            data[row + col * 2] = values[row * 2 + col];

        }

    }

}

void tst_QMatrixNxN::setMatrixDirect(QMatrix3x3& m, const qreal *values)

{

    qreal *data = m.data();

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

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

            data[row + col * 3] = values[row * 3 + col];

        }

    }

}

void tst_QMatrixNxN::setMatrixDirect(QMatrix4x4& m, const qreal *values)

{

    qreal *data = m.data();

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

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

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

        }

    }

}

void tst_QMatrixNxN::setMatrixDirect(QMatrix4x3& m, const qreal *values)

{

    qreal *data = m.data();

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

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

            data[row + col * 3] = values[row * 4 + col];

        }

    }

}

// QVector2/3/4D use float internally, which can sometimes lead

// to precision issues when converting to and from qreal during

// operations involving QMatrix4x4.  This fuzzy compare is slightly

// "fuzzier" than the default qFuzzyCompare for qreal to compensate.

static bool fuzzyCompare(qreal x, qreal y)

{

    return qFuzzyIsNull((float)(x - y));

}

static bool fuzzyCompare(const QVector3D &v1, const QVector3D &v2)

{

    if (!fuzzyCompare(v1.x(), v2.x()))

        return false;

    if (!fuzzyCompare(v1.y(), v2.y()))

        return false;

    if (!fuzzyCompare(v1.z(), v2.z()))

        return false;

    return true;

}

// Determine if a matrix is the same as a specified array of values.

// The values are assumed to be specified in row-major order.

bool tst_QMatrixNxN::isSame(const QMatrix2x2& m, const qreal *values)

{

    const qreal *mv = m.constData();

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

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

            // Check the values using the operator() function.

            if (!fuzzyCompare(m(row, col), values[row * 2 + col])) {

                qDebug() << "floating-point failure at" << row << col << "actual =" << m(row, col) << "expected =" << values[row * 2 + col];

                return false;

            }

            // Check the values using direct access, which verifies that the values

            // are stored internally in column-major order.

            if (!fuzzyCompare(mv[col * 2 + row], values[row * 2 + col])) {

                qDebug() << "column floating-point failure at" << row << col << "actual =" << mv[col * 2 + row] << "expected =" << values[row * 2 + col];

                return false;

            }

        }

    }

    return true;

}

bool tst_QMatrixNxN::isSame(const QMatrix3x3& m, const qreal *values)

{

    const qreal *mv = m.constData();

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

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

            // Check the values using the operator() access function.

            if (!fuzzyCompare(m(row, col), values[row * 3 + col])) {

                qDebug() << "floating-point failure at" << row << col << "actual =" << m(row, col) << "expected =" << values[row * 3 + col];

                return false;

            }

            // Check the values using direct access, which verifies that the values

            // are stored internally in column-major order.

            if (!fuzzyCompare(mv[col * 3 + row], values[row * 3 + col])) {

                qDebug() << "column floating-point failure at" << row << col << "actual =" << mv[col * 3 + row] << "expected =" << values[row * 3 + col];

                return false;

            }

        }

    }

    return true;

}

bool tst_QMatrixNxN::isSame(const QMatrix4x4& m, const qreal *values)

{

    const qreal *mv = m.constData();

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

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

            // Check the values using the operator() access function.

            if (!fuzzyCompare(m(row, col), values[row * 4 + col])) {

                qDebug() << "floating-point failure at" << row << col << "actual =" << m(row, col) << "expected =" << values[row * 4 + col];

                return false;

            }

            // Check the values using direct access, which verifies that the values

            // are stored internally in column-major order.

            if (!fuzzyCompare(mv[col * 4 + row], values[row * 4 + col])) {

                qDebug() << "column floating-point failure at" << row << col << "actual =" << mv[col * 4 + row] << "expected =" << values[row * 4 + col];

                return false;

            }

        }

    }

    return true;

}

bool tst_QMatrixNxN::isSame(const QMatrix4x3& m, const qreal *values)

{

    const qreal *mv = m.constData();

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

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

            // Check the values using the operator() access function.

            if (!fuzzyCompare(m(row, col), values[row * 4 + col])) {

                qDebug() << "floating-point failure at" << row << col << "actual =" << m(row, col) << "expected =" << values[row * 4 + col];

                return false;

            }

            // Check the values using direct access, which verifies that the values

            // are stored internally in column-major order.

            if (!fuzzyCompare(mv[col * 3 + row], values[row * 4 + col])) {

                qDebug() << "column floating-point failure at" << row << col << "actual =" << mv[col * 3 + row] << "expected =" << values[row * 4 + col];

                return false;

            }

        }

    }

    return true;

}

// Determine if a matrix is the identity.

bool tst_QMatrixNxN::isIdentity(const QMatrix2x2& m)

{

    return isSame(m, identityValues2);

}

bool tst_QMatrixNxN::isIdentity(const QMatrix3x3& m)

{

    return isSame(m, identityValues3);

}

bool tst_QMatrixNxN::isIdentity(const QMatrix4x4& m)

{

    return isSame(m, identityValues4);

}

bool tst_QMatrixNxN::isIdentity(const QMatrix4x3& m)

{

    return isSame(m, identityValues4x3);

}

// Test the creation of QMatrix2x2 objects in various ways:

// construct, copy, and modify.

void tst_QMatrixNxN::create2x2()

{

    QMatrix2x2 m1;

    QVERIFY(isIdentity(m1));

    QVERIFY(m1.isIdentity());

    QMatrix2x2 m2;

    setMatrix(m2, uniqueValues2);

    QVERIFY(isSame(m2, uniqueValues2));

    QVERIFY(!m2.isIdentity());

    QMatrix2x2 m3;

    setMatrixDirect(m3, uniqueValues2);

    QVERIFY(isSame(m3, uniqueValues2));

    QMatrix2x2 m4(m3);

    QVERIFY(isSame(m4, uniqueValues2));

    QMatrix2x2 m5;

    m5 = m3;

    QVERIFY(isSame(m5, uniqueValues2));

    m5.setToIdentity();

    QVERIFY(isIdentity(m5));

    QMatrix2x2 m6(uniqueValues2);

    QVERIFY(isSame(m6, uniqueValues2));

    qreal vals[4];

    m6.copyDataTo(vals);

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

        QCOMPARE(vals[index], uniqueValues2[index]);

}

// Test the creation of QMatrix3x3 objects in various ways:

// construct, copy, and modify.

void tst_QMatrixNxN::create3x3()

{

    QMatrix3x3 m1;