Fix selection color and gradient for static optimization

Added separate shaders for rendering selected items, as the texture
mapping that the regular static optimization shaders expect is not
correct for single objects.

Task-number: QTRD-3306
Change-Id: I6eb6cef94a4d2b4e5bdd03748f18db641a9fc4f6
Reviewed-by: Tomi Korpipää <tomi.korpipaa@digia.com>

4 files changed, 111 insertions, 25 deletions

diff --git a/src/datavisualization/engine/abstract3drenderer.cpp b/src/datavisualization/engine/abstract3drenderer.cpp
index aaf5418f..277ef03e 100644
--- a/src/datavisualization/engine/abstract3drenderer.cpp
+++ b/src/datavisualization/engine/abstract3drenderer.cpp
@@ -223,6 +223,18 @@ void Abstract3DRenderer::initGradientShaders(const QString &vertexShader,
     Q_UNUSED(fragmentShader)
 }
 
+void Abstract3DRenderer::initStaticSelectedItemShaders(const QString &vertexShader,
+                                                       const QString &fragmentShader,
+                                                       const QString &gradientVertexShader,
+                                                       const QString &gradientFragmentShader)
+{
+    // Do nothing by default
+    Q_UNUSED(vertexShader)
+    Q_UNUSED(fragmentShader)
+    Q_UNUSED(gradientVertexShader)
+    Q_UNUSED(gradientFragmentShader)
+}
+
 void Abstract3DRenderer::initCustomItemShaders(const QString &vertexShader,
                                                const QString &fragmentShader)
 {
@@ -362,6 +374,10 @@ void Abstract3DRenderer::reInitShaders()
                 && qobject_cast<Scatter3DRenderer *>(this)) {
             initGradientShaders(QStringLiteral(":/shaders/vertexShadow"),
                                 QStringLiteral(":/shaders/fragmentShadow"));
+            initStaticSelectedItemShaders(QStringLiteral(":/shaders/vertexShadow"),
+                                          QStringLiteral(":/shaders/fragmentShadowNoTex"),
+                                          QStringLiteral(":/shaders/vertexShadow"),
+                                          QStringLiteral(":/shaders/fragmentShadowNoTexColorOnY"));
             initShaders(QStringLiteral(":/shaders/vertexShadowNoMatrices"),
                         QStringLiteral(":/shaders/fragmentShadowNoTex"));
         } else {
@@ -379,6 +395,10 @@ void Abstract3DRenderer::reInitShaders()
                 && qobject_cast<Scatter3DRenderer *>(this)) {
             initGradientShaders(QStringLiteral(":/shaders/vertexTexture"),
                                 QStringLiteral(":/shaders/fragmentTexture"));
+            initStaticSelectedItemShaders(QStringLiteral(":/shaders/vertex"),
+                                          QStringLiteral(":/shaders/fragment"),
+                                          QStringLiteral(":/shaders/vertex"),
+                                          QStringLiteral(":/shaders/fragmentColorOnY"));
             initShaders(QStringLiteral(":/shaders/vertexNoMatrices"),
                         QStringLiteral(":/shaders/fragment"));
         } else {
@@ -403,6 +423,10 @@ void Abstract3DRenderer::reInitShaders()
             && qobject_cast<Scatter3DRenderer *>(this)) {
         initGradientShaders(QStringLiteral(":/shaders/vertexTexture"),
                             QStringLiteral(":/shaders/fragmentTextureES2"));
+        initStaticSelectedItemShaders(QStringLiteral(":/shaders/vertex"),
+                                      QStringLiteral(":/shaders/fragmentES2"),
+                                      QStringLiteral(":/shaders/vertex"),
+                                      QStringLiteral(":/shaders/fragmentColorOnYES2"));
         initBackgroundShaders(QStringLiteral(":/shaders/vertexNoMatrices"),
                               QStringLiteral(":/shaders/fragmentES2"));
     } else {
diff --git a/src/datavisualization/engine/abstract3drenderer_p.h b/src/datavisualization/engine/abstract3drenderer_p.h
index 997362d5..4833afaa 100644
--- a/src/datavisualization/engine/abstract3drenderer_p.h
+++ b/src/datavisualization/engine/abstract3drenderer_p.h
@@ -87,6 +87,10 @@ public:
     virtual void updateShadowQuality(QAbstract3DGraph::ShadowQuality quality) = 0;
     virtual void initShaders(const QString &vertexShader, const QString &fragmentShader) = 0;
     virtual void initGradientShaders(const QString &vertexShader, const QString &fragmentShader);
+    virtual void initStaticSelectedItemShaders(const QString &vertexShader,
+                                               const QString &fragmentShader,
+                                               const QString &gradientVertexShader,
+                                               const QString &gradientFragmentShader);
     virtual void initBackgroundShaders(const QString &vertexShader,
                                        const QString &fragmentShader) = 0;
     virtual void initCustomItemShaders(const QString &vertexShader,
diff --git a/src/datavisualization/engine/scatter3drenderer.cpp b/src/datavisualization/engine/scatter3drenderer.cpp
index 3bae9879..5fe69472 100644
--- a/src/datavisualization/engine/scatter3drenderer.cpp
+++ b/src/datavisualization/engine/scatter3drenderer.cpp
@@ -43,6 +43,8 @@ Scatter3DRenderer::Scatter3DRenderer(Scatter3DController *controller)
       m_updateLabels(false),
       m_dotShader(0),
       m_dotGradientShader(0),
+      m_staticSelectedItemGradientShader(0),
+      m_staticSelectedItemShader(0),
       #if defined(QT_OPENGL_ES_2)
       m_pointShader(0),
       #endif
@@ -85,6 +87,8 @@ Scatter3DRenderer::~Scatter3DRenderer()
         m_textureHelper->deleteTexture(&m_bgrTexture);
     }
     delete m_dotShader;
+    delete m_staticSelectedItemGradientShader;
+    delete m_staticSelectedItemShader;
     delete m_dotGradientShader;
     delete m_depthShader;
     delete m_selectionShader;
@@ -1007,6 +1011,17 @@ void Scatter3DRenderer::drawScene(const GLuint defaultFboHandle)
                     && m_selectedItemIndex != Scatter3DController::invalidSelectionIndex()) {
                 ScatterRenderItem &item = renderArray[m_selectedItemIndex];
                 if (item.isVisible()) {
+                    ShaderHelper *selectionShader;
+                    if (drawingPoints) {
+                        selectionShader = pointSelectionShader;
+                    } else {
+                        if (colorStyleIsUniform)
+                            selectionShader = m_staticSelectedItemShader;
+                        else
+                            selectionShader = m_staticSelectedItemGradientShader;
+                    }
+                    selectionShader->bind();
+
                     ObjectHelper *dotObj = cache->object();
 
                     QMatrix4x4 modelMatrix;
@@ -1021,6 +1036,15 @@ void Scatter3DRenderer::drawScene(const GLuint defaultFboHandle)
                         }
                         modelMatrix.scale(modelScaler);
                         itModelMatrix.scale(modelScaler);
+
+                        selectionShader->setUniformValue(selectionShader->lightP(),
+                                                         lightPos);
+                        selectionShader->setUniformValue(selectionShader->view(),
+                                                         viewMatrix);
+                        selectionShader->setUniformValue(selectionShader->ambientS(),
+                                                         m_cachedTheme->ambientLightStrength());
+                        selectionShader->setUniformValue(selectionShader->lightColor(),
+                                                         lightColor);
                     }
 
                     QMatrix4x4 MVPMatrix;
@@ -1044,19 +1068,29 @@ void Scatter3DRenderer::drawScene(const GLuint defaultFboHandle)
 
                     if (!drawingPoints) {
                         // Set shader bindings
-                        dotShader->setUniformValue(dotShader->model(), modelMatrix);
-                        dotShader->setUniformValue(dotShader->nModel(),
-                                                   itModelMatrix.inverted().transposed());
+                        selectionShader->setUniformValue(selectionShader->model(), modelMatrix);
+                        selectionShader->setUniformValue(selectionShader->nModel(),
+                                                         itModelMatrix.inverted().transposed());
+                        if (!colorStyleIsUniform) {
+                            if (colorStyle == Q3DTheme::ColorStyleObjectGradient) {
+                                selectionShader->setUniformValue(selectionShader->gradientMin(),
+                                                                 0.0f);
+                                selectionShader->setUniformValue(selectionShader->gradientHeight(),
+                                                                 0.5f);
+                            } else {
+                                // Each dot is of uniform color according to its Y-coordinate
+                                selectionShader->setUniformValue(selectionShader->gradientHeight(),
+                                                                 0.0f);
+                                selectionShader->setUniformValue(selectionShader->gradientMin(),
+                                                                 (item.translation().y() + m_scaleY)
+                                                                 * rangeGradientYScaler);
+                            }
+                        }
                     }
 
-                    dotShader->setUniformValue(dotShader->MVP(), MVPMatrix);
-                    if (useColor) {
-                        dotShader->setUniformValue(dotShader->color(), dotColor);
-                    } else if (colorStyle == Q3DTheme::ColorStyleRangeGradient) {
-                        dotShader->setUniformValue(dotShader->gradientMin(),
-                                                   (item.translation().y() + m_scaleY)
-                                                   * rangeGradientYScaler);
-                    }
+                    selectionShader->setUniformValue(selectionShader->MVP(), MVPMatrix);
+                    if (useColor)
+                        selectionShader->setUniformValue(selectionShader->color(), dotColor);
 
                     if (!drawingPoints) {
                         glEnable(GL_POLYGON_OFFSET_FILL);
@@ -1068,26 +1102,32 @@ void Scatter3DRenderer::drawScene(const GLuint defaultFboHandle)
                         if (!drawingPoints) {
                             // Set shadow shader bindings
                             QMatrix4x4 depthMVPMatrix = depthProjectionViewMatrix * modelMatrix;
-                            dotShader->setUniformValue(dotShader->depth(), depthMVPMatrix);
-                            dotShader->setUniformValue(dotShader->lightS(), lightStrength / 10.0f);
+                            selectionShader->setUniformValue(selectionShader->shadowQ(),
+                                                             m_shadowQualityToShader);
+                            selectionShader->setUniformValue(selectionShader->depth(),
+                                                             depthMVPMatrix);
+                            selectionShader->setUniformValue(selectionShader->lightS(),
+                                                             lightStrength / 10.0f);
 
                             // Draw the object
-                            m_drawer->drawObject(dotShader, dotObj, gradientTexture, m_depthTexture);
+                            m_drawer->drawObject(selectionShader, dotObj, gradientTexture,
+                                                 m_depthTexture);
                         } else {
                             // Draw the object
-                            m_drawer->drawPoint(dotShader);
+                            m_drawer->drawPoint(selectionShader);
                         }
                     } else
 #endif
                     {
                         if (!drawingPoints) {
                             // Set shadowless shader bindings
-                            dotShader->setUniformValue(dotShader->lightS(), lightStrength);
+                            selectionShader->setUniformValue(selectionShader->lightS(),
+                                                             lightStrength);
                             // Draw the object
-                            m_drawer->drawObject(dotShader, dotObj, gradientTexture);
+                            m_drawer->drawObject(selectionShader, dotObj, gradientTexture);
                         } else {
                             // Draw the object
-                            m_drawer->drawPoint(dotShader);
+                            m_drawer->drawPoint(selectionShader);
                         }
                     }
 
@@ -2235,8 +2275,7 @@ void Scatter3DRenderer::calculateSceneScalingFactors()
 
 void Scatter3DRenderer::initShaders(const QString &vertexShader, const QString &fragmentShader)
 {
-    if (m_dotShader)
-        delete m_dotShader;
+    delete m_dotShader;
     m_dotShader = new ShaderHelper(this, vertexShader, fragmentShader);
     m_dotShader->initialize();
 }
@@ -2244,17 +2283,30 @@ void Scatter3DRenderer::initShaders(const QString &vertexShader, const QString &
 void Scatter3DRenderer::initGradientShaders(const QString &vertexShader,
                                             const QString &fragmentShader)
 {
-    if (m_dotGradientShader)
-        delete m_dotGradientShader;
-
+    delete m_dotGradientShader;
     m_dotGradientShader = new ShaderHelper(this, vertexShader, fragmentShader);
     m_dotGradientShader->initialize();
+
+}
+
+void Scatter3DRenderer::initStaticSelectedItemShaders(const QString &vertexShader,
+                                                      const QString &fragmentShader,
+                                                      const QString &gradientVertexShader,
+                                                      const QString &gradientFragmentShader)
+{
+    delete m_staticSelectedItemShader;
+    m_staticSelectedItemShader = new ShaderHelper(this, vertexShader, fragmentShader);
+    m_staticSelectedItemShader->initialize();
+
+    delete m_staticSelectedItemGradientShader;
+    m_staticSelectedItemGradientShader = new ShaderHelper(this, gradientVertexShader,
+                                                          gradientFragmentShader);
+    m_staticSelectedItemGradientShader->initialize();
 }
 
 void Scatter3DRenderer::initSelectionShader()
 {
-    if (m_selectionShader)
-        delete m_selectionShader;
+    delete m_selectionShader;
     m_selectionShader = new ShaderHelper(this, QStringLiteral(":/shaders/vertexPlainColor"),
                                          QStringLiteral(":/shaders/fragmentPlainColor"));
     m_selectionShader->initialize();
diff --git a/src/datavisualization/engine/scatter3drenderer_p.h b/src/datavisualization/engine/scatter3drenderer_p.h
index d882d59f..f492fc05 100644
--- a/src/datavisualization/engine/scatter3drenderer_p.h
+++ b/src/datavisualization/engine/scatter3drenderer_p.h
@@ -53,6 +53,8 @@ private:
     bool m_updateLabels;
     ShaderHelper *m_dotShader;
     ShaderHelper *m_dotGradientShader;
+    ShaderHelper *m_staticSelectedItemGradientShader;
+    ShaderHelper *m_staticSelectedItemShader;
 #if defined(QT_OPENGL_ES_2)
     ShaderHelper *m_pointShader;
 #endif
@@ -116,6 +118,10 @@ protected:
 private:
     virtual void initShaders(const QString &vertexShader, const QString &fragmentShader);
     virtual void initGradientShaders(const QString &vertexShader, const QString &fragmentShader);
+    virtual void initStaticSelectedItemShaders(const QString &vertexShader,
+                                               const QString &fragmentShader,
+                                               const QString &gradientVertexShader,
+                                               const QString &gradientFragmentShader);
     virtual void updateShadowQuality(QAbstract3DGraph::ShadowQuality quality);
     virtual void updateTextures();
     virtual void fixMeshFileName(QString &fileName, QAbstract3DSeries::Mesh mesh);