Fix labels and grid lines changing size when aspect ratio is changed

Since shaders needed fixing anyway for surface because of this,
also implements the support for object gradients for surface,
which was missing.

Task-number: QTRD-2666
Task-number: QTRD-3211
Change-Id: I0c5da7fdfef308a96ec0bae4750fd22035da4e82
Reviewed-by: Mika Salmela <mika.salmela@digia.com>

2 files changed, 45 insertions, 76 deletions

diff --git a/src/datavisualization/utils/surfaceobject.cpp b/src/datavisualization/utils/surfaceobject.cpp
index f8675912..a98f2f2a 100644
--- a/src/datavisualization/utils/surfaceobject.cpp
+++ b/src/datavisualization/utils/surfaceobject.cpp
@@ -69,24 +69,14 @@ void SurfaceObject::setUpSmoothData(const QSurfaceDataArray &dataArray, const QR
         uvs.resize(totalSize);
     int totalIndex = 0;
 
-    AxisRenderCache &xCache = flipXZ ? m_axisCacheZ : m_axisCacheX;
-    AxisRenderCache &zCache = flipXZ ? m_axisCacheX : m_axisCacheZ;
+    // Init min and max to ridiculous values
+    m_minY = 10000000.0;
+    m_maxY = -10000000.0f;
 
     for (int i = 0; i < m_rows; i++) {
         const QSurfaceDataRow &p = *dataArray.at(i);
         for (int j = 0; j < m_columns; j++) {
-            const QSurfaceDataItem &data = p.at(j);
-            float normalizedX;
-            float normalizedZ;
-            if (polar) {
-                // Slice don't use polar, so don't care about flip
-                m_renderer->calculatePolarXZ(data.position(), normalizedX, normalizedZ);
-            } else {
-                normalizedX = xCache.positionAt(data.x());
-                normalizedZ = zCache.positionAt(data.z());
-            }
-            float normalizedY = m_axisCacheY.positionAt(data.y());
-            m_vertices[totalIndex] = QVector3D(normalizedX, normalizedY, normalizedZ);
+            getNormalizedVertex(p.at(j), m_vertices[totalIndex], polar, flipXZ);
             if (changeGeometry)
                 uvs[totalIndex] = QVector2D(GLfloat(j) * uvX, GLfloat(i) * uvY);
             totalIndex++;
@@ -151,19 +141,8 @@ void SurfaceObject::updateSmoothRow(const QSurfaceDataArray &dataArray, int rowI
     int p = rowIndex * m_columns;
     const QSurfaceDataRow &dataRow = *dataArray.at(rowIndex);
 
-    for (int j = 0; j < m_columns; j++) {
-        const QSurfaceDataItem &data = dataRow.at(j);
-        float normalizedX;
-        float normalizedZ;
-        if (polar) {
-            m_renderer->calculatePolarXZ(data.position(), normalizedX, normalizedZ);
-        } else {
-            normalizedX = m_axisCacheX.positionAt(data.x());
-            normalizedZ = m_axisCacheZ.positionAt(data.z());
-        }
-        float normalizedY = m_axisCacheY.positionAt(data.y());
-        m_vertices[p++] = QVector3D(normalizedX, normalizedY, normalizedZ);
-    }
+    for (int j = 0; j < m_columns; j++)
+        getNormalizedVertex(dataRow.at(j), m_vertices[p++], polar, false);
 
     // Create normals
     int colLimit = m_columns - 1;
@@ -214,17 +193,8 @@ void SurfaceObject::updateSmoothItem(const QSurfaceDataArray &dataArray, int row
                                      bool polar)
 {
     // Update a vertice
-    const QSurfaceDataItem &data = dataArray.at(row)->at(column);
-    float normalizedX;
-    float normalizedZ;
-    if (polar) {
-        m_renderer->calculatePolarXZ(data.position(), normalizedX, normalizedZ);
-    } else {
-        normalizedX = m_axisCacheX.positionAt(data.x());
-        normalizedZ = m_axisCacheZ.positionAt(data.z());
-    }
-    float normalizedY = m_axisCacheY.positionAt(data.y());
-    m_vertices[row * m_columns + column] = QVector3D(normalizedX, normalizedY, normalizedZ);
+    getNormalizedVertex(dataArray.at(row)->at(column),
+                        m_vertices[row * m_columns + column], polar, false);
 
     // Create normals
     int startRow = row;
@@ -376,24 +346,14 @@ void SurfaceObject::setUpData(const QSurfaceDataArray &dataArray, const QRect &s
     int doubleColumns = m_columns * 2 - 2;
     int rowColLimit = rowLimit * doubleColumns;
 
-    AxisRenderCache &xCache = flipXZ ? m_axisCacheZ : m_axisCacheX;
-    AxisRenderCache &zCache = flipXZ ? m_axisCacheX : m_axisCacheZ;
+    // Init min and max to ridiculous values
+    m_minY = 10000000.0;
+    m_maxY = -10000000.0f;
 
     for (int i = 0; i < m_rows; i++) {
         const QSurfaceDataRow &row = *dataArray.at(i);
         for (int j = 0; j < m_columns; j++) {
-            const QSurfaceDataItem &data = row.at(j);
-            float normalizedX;
-            float normalizedZ;
-            if (polar) {
-                // Slice don't use polar, so don't care about flip
-                m_renderer->calculatePolarXZ(data.position(), normalizedX, normalizedZ);
-            } else {
-                normalizedX = xCache.positionAt(data.x());
-                normalizedZ = zCache.positionAt(data.z());
-            }
-            float normalizedY = m_axisCacheY.positionAt(data.y());
-            m_vertices[totalIndex] = QVector3D(normalizedX, normalizedY, normalizedZ);
+            getNormalizedVertex(row.at(j), m_vertices[totalIndex], polar, flipXZ);
             if (changeGeometry)
                 uvs[totalIndex] = QVector2D(GLfloat(j) * uvX, GLfloat(i) * uvY);
 
@@ -475,18 +435,7 @@ void SurfaceObject::updateCoarseRow(const QSurfaceDataArray &dataArray, int rowI
     const QSurfaceDataRow &dataRow = *dataArray.at(rowIndex);
 
     for (int j = 0; j < m_columns; j++) {
-        const QSurfaceDataItem &data = dataRow.at(j);
-        float normalizedX;
-        float normalizedZ;
-        if (polar) {
-            m_renderer->calculatePolarXZ(data.position(), normalizedX, normalizedZ);
-        } else {
-            normalizedX = m_axisCacheX.positionAt(data.x());
-            normalizedZ = m_axisCacheZ.positionAt(data.z());
-        }
-        float normalizedY = m_axisCacheY.positionAt(data.y());
-        m_vertices[p++] = QVector3D(normalizedX, normalizedY, normalizedZ);
-
+        getNormalizedVertex(dataRow.at(j), m_vertices[p++], polar, false);
         if (j > 0 && j < colLimit) {
             m_vertices[p] = m_vertices[p - 1];
             p++;
@@ -528,18 +477,7 @@ void SurfaceObject::updateCoarseItem(const QSurfaceDataArray &dataArray, int row
 
     // Update a vertice
     int p = row * doubleColumns + column * 2 - (column > 0);
-    const QSurfaceDataItem &data = dataArray.at(row)->at(column);
-    float normalizedX;
-    float normalizedZ;
-    if (polar) {
-        m_renderer->calculatePolarXZ(data.position(), normalizedX, normalizedZ);
-    } else {
-        normalizedX = m_axisCacheX.positionAt(data.x());
-        normalizedZ = m_axisCacheZ.positionAt(data.z());
-    }
-    float normalizedY = m_axisCacheY.positionAt(data.y());
-    m_vertices[p] = QVector3D(normalizedX, normalizedY, normalizedZ);
-    p++;
+    getNormalizedVertex(dataArray.at(row)->at(column), m_vertices[p++], polar, false);
 
     if (column > 0 && column < colLimit)
         m_vertices[p] = m_vertices[p - 1];
@@ -714,6 +652,31 @@ bool SurfaceObject::checkFlipNormal(const QSurfaceDataArray &array)
     return ascendingX != ascendingZ;
 }
 
+void SurfaceObject::getNormalizedVertex(const QSurfaceDataItem &data, QVector3D &vertex,
+                                        bool polar, bool flipXZ)
+{
+    float normalizedX;
+    float normalizedZ;
+    if (polar) {
+        // Slice don't use polar, so don't care about flip
+        m_renderer->calculatePolarXZ(data.position(), normalizedX, normalizedZ);
+    } else {
+        if (flipXZ) {
+            normalizedX = m_axisCacheZ.positionAt(data.x());
+            normalizedZ = m_axisCacheX.positionAt(data.z());
+        } else {
+            normalizedX = m_axisCacheX.positionAt(data.x());
+            normalizedZ = m_axisCacheZ.positionAt(data.z());
+        }
+    }
+    float normalizedY = m_axisCacheY.positionAt(data.y());
+    m_minY = qMin(normalizedY, m_minY);
+    m_maxY = qMax(normalizedY, m_maxY);
+    vertex.setX(normalizedX);
+    vertex.setY(normalizedY);
+    vertex.setZ(normalizedZ);
+}
+
 GLuint SurfaceObject::gridElementBuf()
 {
     if (!m_meshDataLoaded)
diff --git a/src/datavisualization/utils/surfaceobject_p.h b/src/datavisualization/utils/surfaceobject_p.h
index 54e6dec3..b3ba80e9 100644
--- a/src/datavisualization/utils/surfaceobject_p.h
+++ b/src/datavisualization/utils/surfaceobject_p.h
@@ -70,6 +70,8 @@ public:
     GLuint gridIndexCount();
     QVector3D vertexAt(int column, int row);
     void clear();
+    float minYValue() const { return m_minY; }
+    float maxYValue() const { return m_maxY; }
 
 private:
     QVector3D normal(const QVector3D &a, const QVector3D &b, const QVector3D &c, bool flipNormal);
@@ -77,6 +79,8 @@ private:
                        const QVector<QVector3D> &normals, const GLint *indices,
                        bool changeGeometry);
     bool checkFlipNormal(const QSurfaceDataArray &array);
+    inline void getNormalizedVertex(const QSurfaceDataItem &data, QVector3D &vertex, bool polar,
+                                    bool flipXZ);
 
 private:
     SurfaceType m_surfaceType;
@@ -91,6 +95,8 @@ private:
     AxisRenderCache &m_axisCacheY;
     AxisRenderCache &m_axisCacheZ;
     Surface3DRenderer *m_renderer;
+    float m_minY;
+    float m_maxY;
 };
 
 QT_END_NAMESPACE_DATAVISUALIZATION