Fix cube geometry to have correct texture coords and tangent vectors

The normal lighting materials were behaving weirdly with cubes. Some
faces were behaving correctly whilst others were inverting the lit and
shadowed sides of normal mapped areas (the slopes). Tracked this down
to some inconsistencies in the generation of the cube geometry.

The cube geometry now generates data consistently such that:

* when you look at each face from the following locations and
  orientations:
** Positive X face with positive y as up vector
** Negative X face with positive y as up vector
** Positive Z face with positive y as up vector
** Negative Z face with positive y as up vector
** Positive Y face with negative z as up vector
** Negative Y face with positive z as up vector

then:

* the u texture coordinate always increases to the right as you look at
  any face of the cube
* the v texture coordinate always increases up the face
* the tangent vector is aligned with the u texture coordinate

and taking special care that the w component is correctly oriented.

This can be tested by using a normal mapped cube with a point light
orbiting around above it takign note of the regions that are lit and
shadowed.

Change-Id: I834749b08efb9e03548e8c749c6281958a4e6329
Reviewed-by: Kevin Ottens <kevin.ottens@kdab.com>

3 files changed, 520 insertions, 1 deletions

diff --git a/tests/auto/render/qcuboidgeometry/qcuboidgeometry.pro b/tests/auto/render/qcuboidgeometry/qcuboidgeometry.pro
new file mode 100644
index 000000000..2599b5fe6
--- /dev/null
+++ b/tests/auto/render/qcuboidgeometry/qcuboidgeometry.pro
@@ -0,0 +1,13 @@
+TEMPLATE = app
+
+TARGET = tst_qcuboidgeometry
+
+QT += 3dextras testlib
+
+CONFIG += testcase
+
+SOURCES += \
+    tst_qcuboidgeometry.cpp
+
+include(../../core/common/common.pri)
+include(../commons/commons.pri)
diff --git a/tests/auto/render/qcuboidgeometry/tst_qcuboidgeometry.cpp b/tests/auto/render/qcuboidgeometry/tst_qcuboidgeometry.cpp
new file mode 100644
index 000000000..ddd9eed22
--- /dev/null
+++ b/tests/auto/render/qcuboidgeometry/tst_qcuboidgeometry.cpp
@@ -0,0 +1,505 @@
+/****************************************************************************
+**
+** Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB).
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the Qt3D module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtTest/QTest>
+#include <QObject>
+#include <Qt3DExtras/qcuboidgeometry.h>
+#include <Qt3DRender/qattribute.h>
+#include <Qt3DRender/qbuffer.h>
+#include <Qt3DRender/qbufferdatagenerator.h>
+#include <QtGui/qopenglcontext.h>
+#include <QtGui/qvector2d.h>
+#include <QtGui/qvector3d.h>
+#include <QtGui/qvector4d.h>
+#include <QtCore/qdebug.h>
+#include <QtCore/qsharedpointer.h>
+#include <QSignalSpy>
+
+namespace {
+
+void generateGeometry(Qt3DRender::QGeometry &geometry)
+{
+    // Get all attributes
+    const QVector<Qt3DRender::QAttribute *> attributes = geometry.attributes();
+
+    // Get all unique data generators from the buffers referenced by the attributes
+    QHash<Qt3DRender::QBufferDataGeneratorPtr, Qt3DRender::QBuffer *> dataGenerators;
+    for (const auto attribute : attributes) {
+        const auto dataGenerator = attribute->buffer()->dataGenerator();
+        if (!dataGenerators.contains(dataGenerator))
+            dataGenerators.insert(dataGenerator, attribute->buffer());
+    }
+
+    // Generate data for each buffer
+    const auto end = dataGenerators.end();
+    for (auto it = dataGenerators.begin(); it != end; ++it) {
+        Qt3DRender::QBufferDataGeneratorPtr dataGenerator = it.key();
+        const QByteArray data = (*dataGenerator)();
+
+        Qt3DRender::QBuffer *buffer = it.value();
+        buffer->setData(data);
+    }
+}
+
+template<typename IndexType>
+IndexType extractIndexData(Qt3DRender::QAttribute *attribute, int index)
+{
+    // Get the raw data
+    const IndexType *typedData = reinterpret_cast<const IndexType *>(attribute->buffer()->data().constData());
+
+    // Offset into the data taking stride and offset into account
+    const IndexType indexValue = *(typedData + index);
+    return indexValue;
+}
+
+template<typename VertexType, typename IndexType>
+VertexType extractVertexData(Qt3DRender::QAttribute *attribute, IndexType index)
+{
+    // Get the raw data
+    const char *rawData = attribute->buffer()->data().constData();
+
+    // Offset into the data taking stride and offset into account
+    const char *vertexData = rawData + (index * attribute->byteStride() + attribute->byteOffset());
+
+    // Construct vertex from the typed data
+    VertexType vertex;
+    const Qt3DRender::QAttribute::VertexBaseType type = attribute->vertexBaseType();
+    switch (type)
+    {
+    case Qt3DRender::QAttribute::Float: {
+        const float *typedVertexData = reinterpret_cast<const float *>(vertexData);
+        const int components = attribute->vertexSize();
+        for (int i = 0; i < components; ++i)
+            vertex[i] = typedVertexData[i];
+        break;
+
+        // TODO: Handle other types as needed
+    }
+
+    default:
+        qWarning() << "Unhandled type";
+        Q_UNREACHABLE();
+        break;
+    }
+
+    return vertex;
+}
+
+}
+
+class tst_QCuboidGeometry : public QObject
+{
+    Q_OBJECT
+private Q_SLOTS:
+    void defaultConstruction()
+    {
+        // WHEN
+        Qt3DExtras::QCuboidGeometry geometry;
+
+        // THEN
+        QCOMPARE(geometry.xExtent(), 1.0f);
+        QCOMPARE(geometry.yExtent(), 1.0f);
+        QCOMPARE(geometry.zExtent(), 1.0f);
+        QCOMPARE(geometry.xyMeshResolution(), QSize(2, 2));
+        QCOMPARE(geometry.yzMeshResolution(), QSize(2, 2));
+        QCOMPARE(geometry.xzMeshResolution(), QSize(2, 2));
+        QVERIFY(geometry.positionAttribute() != nullptr);
+        QCOMPARE(geometry.positionAttribute()->name(), Qt3DRender::QAttribute::defaultPositionAttributeName());
+        QVERIFY(geometry.normalAttribute() != nullptr);
+        QCOMPARE(geometry.normalAttribute()->name(), Qt3DRender::QAttribute::defaultNormalAttributeName());
+        QVERIFY(geometry.texCoordAttribute() != nullptr);
+        QCOMPARE(geometry.texCoordAttribute()->name(), Qt3DRender::QAttribute::defaultTextureCoordinateAttributeName());
+        QVERIFY(geometry.tangentAttribute() != nullptr);
+        QCOMPARE(geometry.tangentAttribute()->name(), Qt3DRender::QAttribute::defaultTangentAttributeName());
+        QVERIFY(geometry.indexAttribute() != nullptr);
+    }
+
+    void properties()
+    {
+        // GIVEN
+        Qt3DExtras::QCuboidGeometry geometry;
+
+        {
+            // WHEN
+            QSignalSpy spy(&geometry, SIGNAL(xExtentChanged(float)));
+            const float newValue = 2.0f;
+            geometry.setXExtent(newValue);
+
+            // THEN
+            QCOMPARE(geometry.xExtent(), newValue);
+            QCOMPARE(spy.count(), 1);
+
+            // WHEN
+            spy.clear();
+            geometry.setXExtent(newValue);
+
+            // THEN
+            QCOMPARE(geometry.xExtent(), newValue);
+            QCOMPARE(spy.count(), 0);
+        }
+
+        {
+            // WHEN
+            QSignalSpy spy(&geometry, SIGNAL(yExtentChanged(float)));
+            const float newValue = 2.0f;
+            geometry.setYExtent(newValue);
+
+            // THEN
+            QCOMPARE(geometry.yExtent(), newValue);
+            QCOMPARE(spy.count(), 1);
+
+            // WHEN
+            spy.clear();
+            geometry.setYExtent(newValue);
+
+            // THEN
+            QCOMPARE(geometry.yExtent(), newValue);
+            QCOMPARE(spy.count(), 0);
+        }
+
+        {
+            // WHEN
+            QSignalSpy spy(&geometry, SIGNAL(zExtentChanged(float)));
+            const float newValue = 2.0f;
+            geometry.setZExtent(newValue);
+
+            // THEN
+            QCOMPARE(geometry.zExtent(), newValue);
+            QCOMPARE(spy.count(), 1);
+
+            // WHEN
+            spy.clear();
+            geometry.setZExtent(newValue);
+
+            // THEN
+            QCOMPARE(geometry.zExtent(), newValue);
+            QCOMPARE(spy.count(), 0);
+        }
+
+        {
+            // WHEN
+            QSignalSpy spy(&geometry, SIGNAL(xyMeshResolutionChanged(QSize)));
+            const auto newValue = QSize(4, 8);
+            geometry.setXYMeshResolution(newValue);
+
+            // THEN
+            QCOMPARE(geometry.xyMeshResolution(), newValue);
+            QCOMPARE(spy.count(), 1);
+
+            // WHEN
+            spy.clear();
+            geometry.setXYMeshResolution(newValue);
+
+            // THEN
+            QCOMPARE(geometry.xyMeshResolution(), newValue);
+            QCOMPARE(spy.count(), 0);
+        }
+
+        {
+            // WHEN
+            QSignalSpy spy(&geometry, SIGNAL(yzMeshResolutionChanged(QSize)));
+            const auto newValue = QSize(4, 8);
+            geometry.setYZMeshResolution(newValue);
+
+            // THEN
+            QCOMPARE(geometry.yzMeshResolution(), newValue);
+            QCOMPARE(spy.count(), 1);
+
+            // WHEN
+            spy.clear();
+            geometry.setYZMeshResolution(newValue);
+
+            // THEN
+            QCOMPARE(geometry.yzMeshResolution(), newValue);
+            QCOMPARE(spy.count(), 0);
+        }
+
+        {
+            // WHEN
+            QSignalSpy spy(&geometry, SIGNAL(xzMeshResolutionChanged(QSize)));
+            const auto newValue = QSize(4, 8);
+            geometry.setXZMeshResolution(newValue);
+
+            // THEN
+            QCOMPARE(geometry.xzMeshResolution(), newValue);
+            QCOMPARE(spy.count(), 1);
+
+            // WHEN
+            spy.clear();
+            geometry.setXZMeshResolution(newValue);
+
+            // THEN
+            QCOMPARE(geometry.xzMeshResolution(), newValue);
+            QCOMPARE(spy.count(), 0);
+        }
+    }
+
+    void generatedGeometryShouldBeConsistent_data()
+    {
+        QTest::addColumn<float>("xExtent");
+        QTest::addColumn<float>("yExtent");
+        QTest::addColumn<float>("zExtent");
+        QTest::addColumn<QSize>("xyMeshResolution");
+        QTest::addColumn<QSize>("yzMeshResolution");
+        QTest::addColumn<QSize>("xzMeshResolution");
+        QTest::addColumn<int>("triangleIndex");
+        QTest::addColumn<QVector<quint16>>("indices");
+        QTest::addColumn<QVector<QVector3D>>("positions");
+        QTest::addColumn<QVector<QVector3D>>("normals");
+        QTest::addColumn<QVector<QVector2D>>("texCoords");
+        QTest::addColumn<QVector<QVector4D>>("tangents");
+
+        {
+            const int triangleIndex = 0;
+            const auto indices = (QVector<quint16>() << 0 << 1 << 2);
+            const auto positions = (QVector<QVector3D>()
+                    << QVector3D(0.5f, -0.5f, -0.5f)
+                    << QVector3D(0.5f, 0.5f, -0.5f)
+                    << QVector3D(0.5f, -0.5f, 0.5f));
+            const auto normals = (QVector<QVector3D>()
+                    << QVector3D(1.0f, 0.0f, 0.0f)
+                    << QVector3D(1.0f, 0.0f, 0.0f)
+                    << QVector3D(1.0f, 0.0f, 0.0f));
+            const auto texCoords = (QVector<QVector2D>()
+                    << QVector2D(0.0f, 0.0f)
+                    << QVector2D(0.0f, 1.0f)
+                    << QVector2D(1.0f, 0.0f));
+            const auto tangents = (QVector<QVector4D>()
+                    << QVector4D(0.0f, 0.0f, 1.0f, -1.0f)
+                    << QVector4D(0.0f, 0.0f, 1.0f, -1.0f)
+                    << QVector4D(0.0f, 0.0f, 1.0f, -1.0f));
+            QTest::newRow("default_positiveX_firstTriangle")
+                    << 1.0f << 1.0f << 1.0f
+                    << QSize(2,2) << QSize(2,2) << QSize(2,2)
+                    << triangleIndex
+                    << indices << positions << normals << texCoords << tangents;
+        }
+
+        {
+            const int triangleIndex = 3;
+            const auto indices = (QVector<quint16>() << 6 << 5 << 7);
+            const auto positions = (QVector<QVector3D>()
+                    << QVector3D(-0.5f, -0.5f, -0.5f)
+                    << QVector3D(-0.5f, 0.5f, 0.5f)
+                    << QVector3D(-0.5f, 0.5f, -0.5f));
+            const auto normals = (QVector<QVector3D>()
+                    << QVector3D(-1.0f, 0.0f, 0.0f)
+                    << QVector3D(-1.0f, 0.0f, 0.0f)
+                    << QVector3D(-1.0f, 0.0f, 0.0f));
+            const auto texCoords = (QVector<QVector2D>()
+                    << QVector2D(1.0f, 0.0f)
+                    << QVector2D(0.0f, 1.0f)
+                    << QVector2D(1.0f, 1.0f));
+            const auto tangents = (QVector<QVector4D>()
+                    << QVector4D(0.0f, 0.0f, -1.0f, -1.0f)
+                    << QVector4D(0.0f, 0.0f, -1.0f, -1.0f)
+                    << QVector4D(0.0f, 0.0f, -1.0f, -1.0f));
+            QTest::newRow("default_negativeX_lastTriangle")
+                    << 1.0f << 1.0f << 1.0f
+                    << QSize(2,2) << QSize(2,2) << QSize(2,2)
+                    << triangleIndex
+                    << indices << positions << normals << texCoords << tangents;
+        }
+
+        {
+            const int triangleIndex = 4;
+            const auto indices = (QVector<quint16>() << 8 << 9 << 10);
+            const auto positions = (QVector<QVector3D>()
+                    << QVector3D(-0.5f, 0.5f, 0.5f)
+                    << QVector3D(0.5f, 0.5f, 0.5f)
+                    << QVector3D(-0.5f, 0.5f, -0.5f));
+            const auto normals = (QVector<QVector3D>()
+                    << QVector3D(0.0f, 1.0f, 0.0f)
+                    << QVector3D(0.0f, 1.0f, 0.0f)
+                    << QVector3D(0.0f, 1.0f, 0.0f));
+            const auto texCoords = (QVector<QVector2D>()
+                    << QVector2D(0.0f, 0.0f)
+                    << QVector2D(1.0f, 0.0f)
+                    << QVector2D(0.0f, 1.0f));
+            const auto tangents = (QVector<QVector4D>()
+                    << QVector4D(1.0f, 0.0f, 0.0f, 1.0f)
+                    << QVector4D(1.0f, 0.0f, 0.0f, 1.0f)
+                    << QVector4D(1.0f, 0.0f, 0.0f, 1.0f));
+            QTest::newRow("default_positiveY_firstTriangle")
+                    << 1.0f << 1.0f << 1.0f
+                    << QSize(2,2) << QSize(2,2) << QSize(2,2)
+                    << triangleIndex
+                    << indices << positions << normals << texCoords << tangents;
+        }
+
+        {
+            const int triangleIndex = 7;
+            const auto indices = (QVector<quint16>() << 14 << 13 << 15);
+            const auto positions = (QVector<QVector3D>()
+                    << QVector3D(-0.5f, -0.5f, 0.5f)
+                    << QVector3D(0.5f, -0.5f, -0.5f)
+                    << QVector3D(0.5f, -0.5f, 0.5f));
+            const auto normals = (QVector<QVector3D>()
+                    << QVector3D(0.0f, -1.0f, 0.0f)
+                    << QVector3D(0.0f, -1.0f, 0.0f)
+                    << QVector3D(0.0f, -1.0f, 0.0f));
+            const auto texCoords = (QVector<QVector2D>()
+                    << QVector2D(0.0f, 1.0f)
+                    << QVector2D(1.0f, 0.0f)
+                    << QVector2D(1.0f, 1.0f));
+            const auto tangents = (QVector<QVector4D>()
+                    << QVector4D(1.0f, 0.0f, 0.0f, 1.0f)
+                    << QVector4D(1.0f, 0.0f, 0.0f, 1.0f)
+                    << QVector4D(1.0f, 0.0f, 0.0f, 1.0f));
+            QTest::newRow("default_negativeY_lastTriangle")
+                    << 1.0f << 1.0f << 1.0f
+                    << QSize(2,2) << QSize(2,2) << QSize(2,2)
+                    << triangleIndex
+                    << indices << positions << normals << texCoords << tangents;
+        }
+
+        {
+            const int triangleIndex = 8;
+            const auto indices = (QVector<quint16>() << 16 << 17 << 18);
+            const auto positions = (QVector<QVector3D>()
+                    << QVector3D(-0.5f, -0.5f, 0.5f)
+                    << QVector3D(0.5f, -0.5f, 0.5f)
+                    << QVector3D(-0.5f, 0.5f, 0.5f));
+            const auto normals = (QVector<QVector3D>()
+                    << QVector3D(0.0f, 0.0f, 1.0f)
+                    << QVector3D(0.0f, 0.0f, 1.0f)
+                    << QVector3D(0.0f, 0.0f, 1.0f));
+            const auto texCoords = (QVector<QVector2D>()
+                    << QVector2D(0.0f, 0.0f)
+                    << QVector2D(1.0f, 0.0f)
+                    << QVector2D(0.0f, 1.0f));
+            const auto tangents = (QVector<QVector4D>()
+                    << QVector4D(1.0f, 0.0f, 0.0f, 1.0f)
+                    << QVector4D(1.0f, 0.0f, 0.0f, 1.0f)
+                    << QVector4D(1.0f, 0.0f, 0.0f, 1.0f));
+            QTest::newRow("default_positiveZ_firstTriangle")
+                    << 1.0f << 1.0f << 1.0f
+                    << QSize(2,2) << QSize(2,2) << QSize(2,2)
+                    << triangleIndex
+                    << indices << positions << normals << texCoords << tangents;
+        }
+
+        {
+            const int triangleIndex = 11;
+            const auto indices = (QVector<quint16>() << 22 << 21 << 23);
+            const auto positions = (QVector<QVector3D>()
+                    << QVector3D(0.5f, 0.5f, -0.5f)
+                    << QVector3D(-0.5f, -0.5f, -0.5f)
+                    << QVector3D(-0.5f, 0.5f, -0.5f));
+            const auto normals = (QVector<QVector3D>()
+                    << QVector3D(0.0f, 0.0f, -1.0f)
+                    << QVector3D(0.0f, 0.0f, -1.0f)
+                    << QVector3D(0.0f, 0.0f, -1.0f));
+            const auto texCoords = (QVector<QVector2D>()
+                    << QVector2D(0.0f, 1.0f)
+                    << QVector2D(1.0f, 0.0f)
+                    << QVector2D(1.0f, 1.0f));
+            const auto tangents = (QVector<QVector4D>()
+                    << QVector4D(-1.0f, 0.0f, 0.0f, 1.0f)
+                    << QVector4D(-1.0f, 0.0f, 0.0f, 1.0f)
+                    << QVector4D(-1.0f, 0.0f, 0.0f, 1.0f));
+            QTest::newRow("default_negativeZ_lastTriangle")
+                    << 1.0f << 1.0f << 1.0f
+                    << QSize(2,2) << QSize(2,2) << QSize(2,2)
+                    << triangleIndex
+                    << indices << positions << normals << texCoords << tangents;
+        }
+    }
+
+    void generatedGeometryShouldBeConsistent()
+    {
+        // GIVEN
+        Qt3DExtras::QCuboidGeometry geometry;
+        const QVector<Qt3DRender::QAttribute *> attributes = geometry.attributes();
+        Qt3DRender::QAttribute *positionAttribute = geometry.positionAttribute();
+        Qt3DRender::QAttribute *normalAttribute = geometry.normalAttribute();
+        Qt3DRender::QAttribute *texCoordAttribute = geometry.texCoordAttribute();
+        Qt3DRender::QAttribute *tangentAttribute = geometry.tangentAttribute();
+        Qt3DRender::QAttribute *indexAttribute = geometry.indexAttribute();
+
+        // WHEN
+        QFETCH(float, xExtent);
+        QFETCH(float, yExtent);
+        QFETCH(float, zExtent);
+        QFETCH(QSize, xyMeshResolution);
+        QFETCH(QSize, yzMeshResolution);
+        QFETCH(QSize, xzMeshResolution);
+        geometry.setXExtent(xExtent);
+        geometry.setYExtent(yExtent);
+        geometry.setZExtent(zExtent);
+        geometry.setXYMeshResolution(xyMeshResolution);
+        geometry.setYZMeshResolution(yzMeshResolution);
+        geometry.setXZMeshResolution(xzMeshResolution);
+
+        generateGeometry(geometry);
+
+        // THEN
+
+        // Check buffer of each attribute is valid and actually has some data
+        for (const auto &attribute : attributes) {
+            Qt3DRender::QBuffer *buffer = attribute->buffer();
+            QVERIFY(buffer != nullptr);
+            QVERIFY(buffer->data().size() != 0);
+        }
+
+        // Check some data in the buffers
+
+        // Check specific indices and vertex attributes of triangle under test
+        QFETCH(int, triangleIndex);
+        QFETCH(QVector<quint16>, indices);
+        QFETCH(QVector<QVector3D>, positions);
+        QFETCH(QVector<QVector3D>, normals);
+        QFETCH(QVector<QVector2D>, texCoords);
+        QFETCH(QVector<QVector4D>, tangents);
+
+        int i = 0;
+        for (auto index : indices) {
+            const auto testIndex = extractIndexData<quint16>(indexAttribute, 3 * triangleIndex + i);
+            QCOMPARE(testIndex, indices.at(i));
+
+            const auto position = extractVertexData<QVector3D, quint32>(positionAttribute, index);
+            QCOMPARE(position, positions.at(i));
+
+            const auto normal = extractVertexData<QVector3D, quint32>(normalAttribute, index);
+            QCOMPARE(normal, normals.at(i));
+
+            const auto texCoord = extractVertexData<QVector2D, quint32>(texCoordAttribute, index);
+            QCOMPARE(texCoord, texCoords.at(i));
+
+            const auto tangent = extractVertexData<QVector4D, quint32>(tangentAttribute, index);
+            QCOMPARE(tangent, tangents.at(i));
+
+            ++i;
+        }
+    }
+};
+
+
+QTEST_APPLESS_MAIN(tst_QCuboidGeometry)
+
+#include "tst_qcuboidgeometry.moc"
diff --git a/tests/auto/render/render.pro b/tests/auto/render/render.pro
index 9f8798314..12a15fc41 100644
--- a/tests/auto/render/render.pro
+++ b/tests/auto/render/render.pro
@@ -51,5 +51,6 @@ contains(QT_CONFIG, private_tests) {
         genericlambdajob \
         qgraphicsapifilter \
         qrendersurfaceselector \
-        sortpolicy
+        sortpolicy \
+        qcuboidgeometry
 }