Added support for setting tick count

Change-Id: I1dc92d0241d1ae64d0e515595edfaefb50cb22bd
Change-Id: I1dc92d0241d1ae64d0e515595edfaefb50cb22bd
Reviewed-by: Miikka Heikkinen <miikka.heikkinen@digia.com>

15 files changed, 136 insertions, 116 deletions

diff --git a/examples/barchart/main.cpp b/examples/barchart/main.cpp
index 0f04d8d4..5c2e1c1c 100644
--- a/examples/barchart/main.cpp
+++ b/examples/barchart/main.cpp
@@ -224,6 +224,9 @@ void ChartDataGenerator::addDataSet()
                          {0.0f, 0.0f, 0.0f, 0.0f, 2.0f, 2.0f, 0.3f},      // week 4
                          {3.0f, 3.0f, 6.0f, 2.0f, 2.0f, 1.0f, 1.0f}};     // week 5
 
+    // Set tick count and step, we want a line every hour -> 7 ticks, step 1 hour
+    m_chart->setTickCount(7, 1.0f);
+
     // Create data set
     QDataSet *dataSet = new QDataSet();
 
diff --git a/examples/spectrum/spectrumapp/main.cpp b/examples/spectrum/spectrumapp/main.cpp
index b6f9eabe..4296a347 100644
--- a/examples/spectrum/spectrumapp/main.cpp
+++ b/examples/spectrum/spectrumapp/main.cpp
@@ -88,6 +88,9 @@ MainApp::MainApp(Q3DBars *window)
     m_chart->setupSampleSpace(SpectrumNumBands, SpectrumNumBands * 2);
     // Disable grid
     m_chart->setGridEnabled(false);
+    // Disable auto-scaling of height by defining tick count and step, even though we don't draw grid
+    // By setting count to 1 and step to the max we can get, we lock the scale of the bars.
+    m_chart->setTickCount(1, 1.0f);
     // Disable shadows
     m_chart->setShadowQuality(ShadowNone);
 #if USE_CONES
diff --git a/examples/widget/chart.cpp b/examples/widget/chart.cpp
index b5668ad1..741b04c7 100644
--- a/examples/widget/chart.cpp
+++ b/examples/widget/chart.cpp
@@ -55,7 +55,10 @@ ChartModifier::ChartModifier(Q3DBars *barchart)
       m_barDepth(1.0f),
       m_barSpacingX(0.1f),
       m_barSpacingZ(0.1f),
-      m_fontSize(20)
+      m_fontSize(20),
+      m_ticks(20),
+      m_tickStep(1),
+      m_minval(-15.2f)
 {
     // Don't set any styles or specifications, start from defaults
 }
@@ -80,11 +83,14 @@ void ChartModifier::restart(bool dynamicData)
         // Set selection mode to zoom row
         m_chart->setSelectionMode(ModeZoomRow);
         m_chart->setFont(QFont("Times Roman", 20));
+        m_chart->setTickCount(m_ticks, m_tickStep, m_minval);
     } else {
-        // Set up sample space; make it as deep as it's wide
+        // Set up sample space
         m_chart->setupSampleSpace(m_columnCount, m_rowCount);
         // Set selection mode to full
         m_chart->setSelectionMode(ModeBarRowAndColumn);
+        // Reset tick count to default
+        m_chart->setTickCount(0, 0);
     }
 }
 
@@ -133,6 +139,11 @@ void ChartModifier::addDataSet()
         dataRow++;
     }
 
+    // Set tick count (4 steps of 5 degrees, with absolute minimum of -16C, even though we don't have quite that low temperatures in the data)
+    //m_chart->setTickCount(4, 5, -16.0f);
+    // ..or 20 steps of 1 degree, with absolute minimum of -15.2C
+    m_chart->setTickCount(m_ticks, m_tickStep, m_minval);
+
     // Set up sample space based on prepared data
     m_chart->setupSampleSpace(months.size(), years.size());
 
diff --git a/examples/widget/chart.h b/examples/widget/chart.h
index 48507a95..81b123e5 100644
--- a/examples/widget/chart.h
+++ b/examples/widget/chart.h
@@ -92,6 +92,9 @@ private:
     float m_barSpacingX;
     float m_barSpacingZ;
     int m_fontSize;
+    int m_ticks;
+    float m_tickStep;
+    float m_minval;
 };
 
 #endif
diff --git a/src/engine/q3dbars.cpp b/src/engine/q3dbars.cpp
index b2b19d4c..c991cd4b 100644
--- a/src/engine/q3dbars.cpp
+++ b/src/engine/q3dbars.cpp
@@ -609,7 +609,6 @@ void Q3DBars::drawScene()
                    d_ptr->m_sceneViewPort.width(), d_ptr->m_sceneViewPort.height());
     }
 
-#if 1
     // Skip selection mode drawing if we're zoomed or have no selection mode
     if (!d_ptr->m_zoomActivated && d_ptr->m_selectionMode > ModeNone) {
         // Bind selection shader
@@ -1092,9 +1091,13 @@ void Q3DBars::drawScene()
         }
 
         // Wall lines: back wall
-        GLfloat heightStep = d_ptr->m_heightNormalizer / 2.5; // TODO: Replace 2.5 with a dynamic number deduced from scene?
-        for (GLfloat barHeight = heightStep; barHeight <= d_ptr->m_heightNormalizer * 2.0f;
-             barHeight += heightStep) {
+        GLfloat heightStep = d_ptr->m_heightNormalizer / 5.0f; // default to 5 lines
+
+        if (d_ptr->m_tickCount > 0)
+            heightStep = d_ptr->m_tickStep;
+
+        for (GLfloat lineHeight = heightStep; lineHeight <= d_ptr->m_heightNormalizer;
+             lineHeight += heightStep) {
             QMatrix4x4 modelMatrix;
             QMatrix4x4 MVPMatrix;
             QMatrix4x4 depthMVPMatrix;
@@ -1102,11 +1105,13 @@ void Q3DBars::drawScene()
 
             if (d_ptr->m_zFlipped) {
                 modelMatrix.translate(0.0f,
-                                      barHeight / d_ptr->m_heightNormalizer - d_ptr->m_yAdjustment,
+                                      2.0f * lineHeight / d_ptr->m_heightNormalizer
+                                      - d_ptr->m_yAdjustment,
                                       d_ptr->m_columnDepth / d_ptr->m_scaleFactor + zComp);
             } else {
                 modelMatrix.translate(0.0f,
-                                      barHeight / d_ptr->m_heightNormalizer - d_ptr->m_yAdjustment,
+                                      2.0f * lineHeight / d_ptr->m_heightNormalizer
+                                      - d_ptr->m_yAdjustment,
                                       -d_ptr->m_columnDepth / d_ptr->m_scaleFactor + zComp);
             }
             modelMatrix.scale(QVector3D(d_ptr->m_rowWidth / d_ptr->m_scaleFactor, gridLineWidth,
@@ -1146,8 +1151,8 @@ void Q3DBars::drawScene()
         }
 
         // Wall lines: side wall
-        for (GLfloat barHeight = heightStep; barHeight <= d_ptr->m_heightNormalizer * 2.0f;
-             barHeight += heightStep) {
+        for (GLfloat lineHeight = heightStep; lineHeight <= d_ptr->m_heightNormalizer;
+             lineHeight += heightStep) {
             QMatrix4x4 modelMatrix;
             QMatrix4x4 MVPMatrix;
             QMatrix4x4 depthMVPMatrix;
@@ -1155,11 +1160,13 @@ void Q3DBars::drawScene()
 
             if (d_ptr->m_xFlipped) {
                 modelMatrix.translate(d_ptr->m_rowWidth / d_ptr->m_scaleFactor,
-                                      barHeight / d_ptr->m_heightNormalizer - d_ptr->m_yAdjustment,
+                                      2.0f * lineHeight / d_ptr->m_heightNormalizer
+                                      - d_ptr->m_yAdjustment,
                                       zComp);
             } else {
                 modelMatrix.translate(-d_ptr->m_rowWidth / d_ptr->m_scaleFactor,
-                                      barHeight / d_ptr->m_heightNormalizer - d_ptr->m_yAdjustment,
+                                      2.0f * lineHeight / d_ptr->m_heightNormalizer
+                                      - d_ptr->m_yAdjustment,
                                       zComp);
             }
             modelMatrix.scale(QVector3D(gridLineWidth, gridLineWidth,
@@ -1394,17 +1401,12 @@ void Q3DBars::drawScene()
 
     // Release label shader
     d_ptr->m_labelShader->release();
-#endif
 }
 
 void Q3DBars::mousePressEvent(QMouseEvent *event)
 {
-    // TODO: for testing shaders
-    //static GLint shaderNo = 1;
-    //qDebug() << "mouse button pressed" << event->button();
     if (Qt::LeftButton == event->button()) {
         if (d_ptr->m_zoomActivated) {
-            //qDebug() << event->pos().x() << event->pos().y() << d_ptr->m_sceneViewPort << d_ptr->m_zoomViewPort;
             if (event->pos().x() <= d_ptr->m_sceneViewPort.width()
                     && event->pos().y() <= d_ptr->m_sceneViewPort.height()) {
                 d_ptr->m_mousePressed = Q3DBarsPrivate::MouseOnOverview;
@@ -1426,31 +1428,12 @@ void Q3DBars::mousePressEvent(QMouseEvent *event)
         d_ptr->m_mousePressed = Q3DBarsPrivate::MouseRotating;
         // update mouse positions to prevent jumping when releasing or repressing a button
         d_ptr->m_mousePos = event->pos();
-
-        // TODO: testing shaders
-        //        if (++shaderNo > 3)
-        //            shaderNo = 1;
-        //        switch (shaderNo) {
-        //        case 1:
-        //            d_ptr->initShaders(QStringLiteral(":/shaders/vertex")
-        //                               , QStringLiteral(":/shaders/fragment"));
-        //            break;
-        //        case 2:
-        //            d_ptr->initShaders(QStringLiteral(":/shaders/vertex")
-        //                               , QStringLiteral(":/shaders/fragmentColorOnY"));
-        //            break;
-        //        case 3:
-        //            d_ptr->initShaders(QStringLiteral(":/shaders/vertex")
-        //                               , QStringLiteral(":/shaders/fragmentAmbient"));
-        //            break;
-        //        }
     }
     CameraHelper::updateMousePos(d_ptr->m_mousePos);
 }
 
 void Q3DBars::mouseReleaseEvent(QMouseEvent *event)
 {
-    //qDebug() << "mouse button released" << event->button();
     if (Q3DBarsPrivate::MouseRotating == d_ptr->m_mousePressed) {
         // update mouse positions to prevent jumping when releasing or repressing a button
         d_ptr->m_mousePos = event->pos();
@@ -1461,25 +1444,8 @@ void Q3DBars::mouseReleaseEvent(QMouseEvent *event)
 
 void Q3DBars::mouseMoveEvent(QMouseEvent *event)
 {
-    if (Q3DBarsPrivate::MouseRotating == d_ptr->m_mousePressed) {
-        //qDebug() << "mouse moved while pressed" << event->pos();
+    if (Q3DBarsPrivate::MouseRotating == d_ptr->m_mousePressed)
         d_ptr->m_mousePos = event->pos();
-    }
-#if 0
-    // TODO: Testi - laske kursorin sijainti scenessä
-    QPointF mouse3D((2.0f * event->pos().x() - width()) / height(),
-                    1.0f - (2.0f * event->pos().y()) / height());
-    //qDebug() << "mouse position in scene" << mouse3D;
-
-    // TODO: Testi laske focal point
-    GLfloat focalPoint = tan(45.0f / 2.0f);
-
-    // TODO: Testi - laske viewmatriisin kerroin
-    QVector3D worldRay = QVector3D(0.0f, 0.0f, 0.0f)
-            - QVector3D(mouse3D.x(), mouse3D.y(), -focalPoint);
-    //qDebug() << "worldRay" << worldRay;
-    // multiply viewmatrix with this to get something?
-#endif
 }
 
 void Q3DBars::wheelEvent(QWheelEvent *event)
@@ -1674,6 +1640,15 @@ void Q3DBars::setGridEnabled(bool enable)
     d_ptr->m_gridEnabled = enable;
 }
 
+void Q3DBars::setTickCount(GLint tickCount, GLfloat step, GLfloat minimum)
+{
+    d_ptr->m_tickCount = tickCount;
+    d_ptr->m_tickStep = step;
+    if (tickCount > 0 && step > 0) {
+        d_ptr->m_heightNormalizer = tickCount * step;
+        d_ptr->calculateHeightAdjustment(QPair<float, float>(minimum, d_ptr->m_heightNormalizer));
+    }
+}
 
 void Q3DBars::setShadowQuality(ShadowQuality quality)
 {
@@ -1730,8 +1705,11 @@ void Q3DBars::addDataRow(const QVector<float> &dataRow, const QString &labelRow,
     d_ptr->m_dataSet->addRow(row);
     // Get the limits
     QPair<GLfloat, GLfloat> limits = d_ptr->m_dataSet->d_ptr->limitValues();
-    d_ptr->m_heightNormalizer = (GLfloat)qMax(qFabs(limits.second), qFabs(limits.first));
-    d_ptr->calculateHeightAdjustment(limits);
+    // Don't auto-adjust height if tick count is set
+    if (d_ptr->m_tickCount == 0) {
+        d_ptr->m_heightNormalizer = (GLfloat)qMax(qFabs(limits.second), qFabs(limits.first));
+        d_ptr->calculateHeightAdjustment(limits);
+    }
     d_ptr->m_dataSet->setLabels(d_ptr->m_axisLabelX, d_ptr->m_axisLabelZ, d_ptr->m_axisLabelY,
                                 QVector<QString>(), labelsColumn);
     d_ptr->m_dataSet->d_ptr->verifySize(d_ptr->m_sampleCount.second);
@@ -1748,8 +1726,11 @@ void Q3DBars::addDataRow(const QVector<QDataItem*> &dataRow, const QString &labe
     d_ptr->m_dataSet->addRow(row);
     // Get the limits
     QPair<GLfloat, GLfloat> limits = d_ptr->m_dataSet->d_ptr->limitValues();
-    d_ptr->m_heightNormalizer = (GLfloat)qMax(qFabs(limits.second), qFabs(limits.first));
-    d_ptr->calculateHeightAdjustment(limits);
+    // Don't auto-adjust height if tick count is set
+    if (d_ptr->m_tickCount == 0) {
+        d_ptr->m_heightNormalizer = (GLfloat)qMax(qFabs(limits.second), qFabs(limits.first));
+        d_ptr->calculateHeightAdjustment(limits);
+    }
     d_ptr->m_dataSet->setLabels(d_ptr->m_axisLabelX, d_ptr->m_axisLabelZ, d_ptr->m_axisLabelY,
                                 QVector<QString>(), labelsColumn);
     d_ptr->m_dataSet->d_ptr->verifySize(d_ptr->m_sampleCount.second);
@@ -1767,8 +1748,11 @@ void Q3DBars::addDataRow(QDataRow *dataRow)
     d_ptr->m_dataSet->d_ptr->verifySize(d_ptr->m_sampleCount.second);
     // Get the limits
     QPair<GLfloat, GLfloat> limits = d_ptr->m_dataSet->d_ptr->limitValues();
-    d_ptr->m_heightNormalizer = (GLfloat)qMax(qFabs(limits.second), qFabs(limits.first));
-    d_ptr->calculateHeightAdjustment(limits);
+    // Don't auto-adjust height if tick count is set
+    if (d_ptr->m_tickCount == 0) {
+        d_ptr->m_heightNormalizer = (GLfloat)qMax(qFabs(limits.second), qFabs(limits.first));
+        d_ptr->calculateHeightAdjustment(limits);
+    }
 }
 
 void Q3DBars::addDataSet(const QVector< QVector<float> > &data, const QVector<QString> &labelsRow,
@@ -1799,8 +1783,11 @@ void Q3DBars::addDataSet(const QVector< QVector<float> > &data, const QVector<QS
     }
     // Get the limits
     QPair<GLfloat, GLfloat> limits = d_ptr->m_dataSet->d_ptr->limitValues();
-    d_ptr->m_heightNormalizer = (GLfloat)qMax(qFabs(limits.second), qFabs(limits.first));
-    d_ptr->calculateHeightAdjustment(limits);
+    // Don't auto-adjust height if tick count is set
+    if (d_ptr->m_tickCount == 0) {
+        d_ptr->m_heightNormalizer = (GLfloat)qMax(qFabs(limits.second), qFabs(limits.first));
+        d_ptr->calculateHeightAdjustment(limits);
+    }
     d_ptr->m_dataSet->setLabels(xAxis, zAxis, yAxis, labelsRow, labelsColumn);
     d_ptr->m_dataSet->d_ptr->verifySize(d_ptr->m_sampleCount.second);
 }
@@ -1834,8 +1821,11 @@ void Q3DBars::addDataSet(const QVector< QVector<QDataItem*> > &data,
     }
     // Get the limits
     QPair<GLfloat, GLfloat> limits = d_ptr->m_dataSet->d_ptr->limitValues();
-    d_ptr->m_heightNormalizer = (GLfloat)qMax(qFabs(limits.second), qFabs(limits.first));
-    d_ptr->calculateHeightAdjustment(limits);
+    // Don't auto-adjust height if tick count is set
+    if (d_ptr->m_tickCount == 0) {
+        d_ptr->m_heightNormalizer = (GLfloat)qMax(qFabs(limits.second), qFabs(limits.first));
+        d_ptr->calculateHeightAdjustment(limits);
+    }
     d_ptr->m_dataSet->setLabels(xAxis, zAxis, yAxis, labelsRow, labelsColumn);
     d_ptr->m_dataSet->d_ptr->verifySize(d_ptr->m_sampleCount.second);
 }
@@ -1850,8 +1840,11 @@ void Q3DBars::addDataSet(QDataSet* dataSet)
     // Find highest value
     // Get the limits
     QPair<GLfloat, GLfloat> limits = d_ptr->m_dataSet->d_ptr->limitValues();
-    d_ptr->m_heightNormalizer = (GLfloat)qMax(qFabs(limits.second), qFabs(limits.first));
-    d_ptr->calculateHeightAdjustment(limits);
+    // Don't auto-adjust height if tick count is set
+    if (d_ptr->m_tickCount == 0) {
+        d_ptr->m_heightNormalizer = (GLfloat)qMax(qFabs(limits.second), qFabs(limits.first));
+        d_ptr->calculateHeightAdjustment(limits);
+    }
     // Give drawer to data set
     d_ptr->m_dataSet->d_ptr->setDrawer(d_ptr->m_drawer);
 }
@@ -1914,7 +1907,9 @@ Q3DBarsPrivate::Q3DBarsPrivate(Q3DBars *q)
       m_updateLabels(false),
       m_gridEnabled(true),
       m_shadowQuality(ShadowLow),
-      m_shadowQualityToShader(33.3f)
+      m_shadowQualityToShader(33.3f),
+      m_tickCount(0),
+      m_tickStep(0)
 {
     m_dataSet->d_ptr->setDrawer(m_drawer);
     QObject::connect(m_drawer, &Drawer::drawerChanged, this, &Q3DBarsPrivate::updateTextures);
diff --git a/src/engine/q3dbars.h b/src/engine/q3dbars.h
index 68ffa40a..3e490144 100644
--- a/src/engine/q3dbars.h
+++ b/src/engine/q3dbars.h
@@ -143,6 +143,11 @@ public:
     // Adjust shadow quality
     void setShadowQuality(ShadowQuality quality);
 
+    // Set tick count and step. Note; tickCount * step should be the maximum possible value of data set.
+    // Minimum is the absolute minimum possible value a bar can have. This is especially important to
+    // set if values can be negative.
+    void setTickCount(GLint tickCount, GLfloat step, GLfloat minimum = 0.0f);
+
 protected:
     void mousePressEvent(QMouseEvent *event);
     void mouseReleaseEvent(QMouseEvent *event);
diff --git a/src/engine/q3dbars_p.h b/src/engine/q3dbars_p.h
index 2623b695..30cdb6da 100644
--- a/src/engine/q3dbars_p.h
+++ b/src/engine/q3dbars_p.h
@@ -171,6 +171,8 @@ public:
     bool m_gridEnabled;
     ShadowQuality m_shadowQuality;
     GLfloat m_shadowQualityToShader;
+    GLint m_tickCount;
+    GLfloat m_tickStep;
 };
 
 QTCOMMERCIALDATAVIS3D_END_NAMESPACE
diff --git a/src/engine/q3dmaps.cpp b/src/engine/q3dmaps.cpp
index 698548d7..9ac43daa 100644
--- a/src/engine/q3dmaps.cpp
+++ b/src/engine/q3dmaps.cpp
@@ -400,6 +400,10 @@ void Q3DMaps::drawScene()
         // Release depth shader
         d_ptr->m_depthShader->release();
 
+        // Revert to original viewport
+        glViewport(d_ptr->m_sceneViewPort.x(), d_ptr->m_sceneViewPort.y(),
+                   d_ptr->m_sceneViewPort.width(), d_ptr->m_sceneViewPort.height());
+
 #if 0 // Use this if you want to see what is being drawn to the framebuffer
         // You'll also have to comment out GL_COMPARE_R_TO_TEXTURE -line in texturehelper (if using it)
         d_ptr->m_labelShader->bind();
@@ -417,13 +421,8 @@ void Q3DMaps::drawScene()
         glDisable(GL_TEXTURE_2D);
         d_ptr->m_labelShader->release();
 #endif
-#if 1
-
-        // Revert to original viewport
-        glViewport(d_ptr->m_sceneViewPort.x(), d_ptr->m_sceneViewPort.y(),
-                   d_ptr->m_sceneViewPort.width(), d_ptr->m_sceneViewPort.height());
     }
-
+#if 1
     // Skip selection mode drawing if we're zoomed or have no selection mode
     if (!d_ptr->m_zoomActivated && d_ptr->m_selectionMode > ModeNone) {
         // Bind selection shader
diff --git a/src/engine/shaders/fragmentShaderAmbient b/src/engine/shaders/fragmentShaderAmbient
index ccaa07e4..88f850f3 100644
--- a/src/engine/shaders/fragmentShaderAmbient
+++ b/src/engine/shaders/fragmentShaderAmbient
@@ -1,28 +1,32 @@
+#version 120
+
+uniform highp vec3 lightPosition_wrld;
+uniform highp vec3 color_mdl;
+
 varying highp vec3 position_wrld;
 varying highp vec3 normal_cmr;
 varying highp vec3 eyeDirection_cmr;
 varying highp vec3 lightDirection_cmr;
-uniform highp vec3 lightPosition_wrld;
-uniform highp vec3 color_mdl;
+
 void main() {
-        highp vec3 lightColor = vec3(1.0, 1.0, 1.0);
-        highp float lightPower = 10.0;
-        highp vec3 materialAmbientColor = vec3(0.5, 0.5, 0.5) * color_mdl;
-        highp vec3 materialSpecularColor = vec3(0.3, 0.3, 0.3) * color_mdl;
-	highp float distance = length(lightPosition_wrld - position_wrld);
-	highp vec3 n = normalize(normal_cmr);
-	highp vec3 l = normalize(lightDirection_cmr);
-        highp float cosTheta = dot(n, l);
-        if (cosTheta < 0.0) { cosTheta = 0.0; }
-        if (cosTheta > 1.0) { cosTheta = 1.0; }
-        highp vec3 E = normalize(eyeDirection_cmr);
-	highp vec3 R = reflect(-l, n);
-        highp float cosAlpha = dot(E, R);
-        if (cosAlpha < 0.0) { cosAlpha = 0.0; }
-        if (cosAlpha > 1.0) { cosAlpha = 1.0; }
-        gl_FragColor.rgb =
-		materialAmbientColor +
-                materialSpecularColor * lightColor * lightPower * (cosAlpha * cosAlpha * cosAlpha * cosAlpha * cosAlpha) / (distance * distance);
-        gl_FragColor.a = 1.0;
+    highp vec3 lightColor = vec3(1.0, 1.0, 1.0);
+    highp float lightPower = 10.0;
+    highp vec3 materialAmbientColor = vec3(0.5, 0.5, 0.5) * color_mdl;
+    highp vec3 materialSpecularColor = vec3(0.3, 0.3, 0.3) * color_mdl;
+
+    highp float distance = length(lightPosition_wrld - position_wrld);
+
+    highp vec3 n = normalize(normal_cmr);
+    highp vec3 l = normalize(lightDirection_cmr);
+    highp float cosTheta = clamp(dot(n, l), 0.0, 1.0);
+
+    highp vec3 E = normalize(eyeDirection_cmr);
+    highp vec3 R = reflect(-l, n);
+    highp float cosAlpha = clamp(dot(E, R), 0.0, 1.0);
+
+    gl_FragColor.rgb =
+        materialAmbientColor +
+        materialSpecularColor * lightColor * lightPower * pow(cosAlpha, 5) / (distance * distance);
+    gl_FragColor.a = 1.0;
 }
 
diff --git a/src/engine/shaders/fragmentShadowNoTex b/src/engine/shaders/fragmentShadowNoTex
index 31efbf63..a08b6b40 100644
--- a/src/engine/shaders/fragmentShadowNoTex
+++ b/src/engine/shaders/fragmentShadowNoTex
@@ -128,15 +128,6 @@ void main() {
         vec4 shadCoordsPD = shadCoords;
         shadCoordsPD.x += cos(poissonDisk[i].x) / shadowQuality;
         shadCoordsPD.y += sin(poissonDisk[i].y) / shadowQuality;
-        // good for low shadow quality
-        //shadCoordsPD.x += cos(poissonDisk[i].x) / 33.3;
-        //shadCoordsPD.y += sin(poissonDisk[i].y) / 33.3;
-        // good for medium shadow quality
-        //shadCoordsPD.x += cos(poissonDisk[i].x) / 66.7;
-        //shadCoordsPD.y += sin(poissonDisk[i].y) / 66.7;
-        // good for high shadow quality
-        //shadCoordsPD.x += cos(poissonDisk[i].x) / 100;
-        //shadCoordsPD.y += sin(poissonDisk[i].y) / 100;
         visibility += 0.05 * shadow2DProj(shadowMap, shadCoordsPD).r;
     }
     // stratified poisson; produces noise but hides pixel edges well
diff --git a/src/engine/shaders/vertexShader b/src/engine/shaders/vertexShader
index b4ac029c..14f77773 100644
--- a/src/engine/shaders/vertexShader
+++ b/src/engine/shaders/vertexShader
@@ -24,5 +24,5 @@ void main() {
     eyeDirection_cmr = vec3(0.0, 0.0, 0.0) - vertexPosition_cmr;
     vec3 lightPosition_cmr = (V * vec4(lightPosition_wrld, 1.0)).xyz;
     lightDirection_cmr = lightPosition_cmr + eyeDirection_cmr;
-    normal_cmr = (V * itM * vec4(vertexNormal_mdl, 0.0)).xyz; // Use modelMatrix's transposed inverse, as it's scaled
+    normal_cmr = (V * itM * vec4(vertexNormal_mdl, 0.0)).xyz;
 }
diff --git a/src/engine/shaders/vertexShaderSelection b/src/engine/shaders/vertexShaderSelection
index 70082663..64d17e15 100644
--- a/src/engine/shaders/vertexShaderSelection
+++ b/src/engine/shaders/vertexShaderSelection
@@ -1,5 +1,7 @@
-attribute highp vec3 vertexPosition_mdl;
 uniform highp mat4 MVP;
+
+attribute highp vec3 vertexPosition_mdl;
+
 void main() {
     gl_Position = MVP * vec4(vertexPosition_mdl, 1.0);
 }
diff --git a/src/engine/shaders/vertexShaderTexture b/src/engine/shaders/vertexShaderTexture
index fb23b252..01f922e0 100644
--- a/src/engine/shaders/vertexShaderTexture
+++ b/src/engine/shaders/vertexShaderTexture
@@ -1,16 +1,19 @@
-attribute highp vec3 vertexPosition_mdl;
-attribute highp vec2 vertexUV;
-attribute highp vec3 vertexNormal_mdl;
 uniform highp mat4 MVP;
 uniform highp mat4 V;
 uniform highp mat4 M;
 uniform highp mat4 itM;
 uniform highp vec3 lightPosition_wrld;
+
+attribute highp vec3 vertexPosition_mdl;
+attribute highp vec2 vertexUV;
+attribute highp vec3 vertexNormal_mdl;
+
 varying highp vec2 UV;
 varying highp vec3 position_wrld;
 varying highp vec3 normal_cmr;
 varying highp vec3 eyeDirection_cmr;
 varying highp vec3 lightDirection_cmr;
+
 void main() {
     gl_Position = MVP * vec4(vertexPosition_mdl, 1.0);
     position_wrld = (M * vec4(vertexPosition_mdl, 1.0)).xyz;
@@ -18,6 +21,6 @@ void main() {
     eyeDirection_cmr = vec3(0.0, 0.0, 0.0) - vertexPosition_cmr;
     vec3 lightPosition_cmr = (V * vec4(lightPosition_wrld, 1.0)).xyz;
     lightDirection_cmr = lightPosition_cmr + eyeDirection_cmr;
-    normal_cmr = (V * itM * vec4(vertexNormal_mdl, 0.0)).xyz; // Use modelMatrix's transposed inverse, as it's scaled
+    normal_cmr = (V * itM * vec4(vertexNormal_mdl, 0.0)).xyz;
     UV = vertexUV;
 }
diff --git a/src/engine/shaders/vertexShadow b/src/engine/shaders/vertexShadow
index 1a582db8..e29a8a30 100644
--- a/src/engine/shaders/vertexShadow
+++ b/src/engine/shaders/vertexShadow
@@ -5,7 +5,7 @@ uniform highp mat4 V;
 uniform highp mat4 M;
 uniform highp mat4 itM;
 uniform highp mat4 depthMVP;
-uniform highp vec3 lightPosition_wrld; // this is used for light direction, we're just reusing the uniform
+uniform highp vec3 lightPosition_wrld;
 
 attribute highp vec3 vertexPosition_mdl;
 attribute highp vec3 vertexNormal_mdl;
@@ -32,7 +32,6 @@ void main() {
     vec3 vertexPosition_cmr = (V * M * vec4(vertexPosition_mdl, 1.0)).xyz;
     eyeDirection_cmr = vec3(0.0, 0.0, 0.0) - vertexPosition_cmr;
     lightDirection_cmr = (V * vec4(lightPosition_wrld, 0.0)).xyz;
-    normal_cmr = (V * itM * vec4(vertexNormal_mdl, 0.0)).xyz; // Use modelMatrix's transposed inverse, as it's scaled
-    //normal_cmr = (V * M * vec4(vertexNormal_mdl, 0.0)).xyz; // Use modelMatrix's transposed inverse, as it's scaled
+    normal_cmr = (V * itM * vec4(vertexNormal_mdl, 0.0)).xyz;
     UV = vertexUV;
 }
diff --git a/src/engine/theme.cpp b/src/engine/theme.cpp
index de56947d..a9032e25 100644
--- a/src/engine/theme.cpp
+++ b/src/engine/theme.cpp
@@ -265,7 +265,7 @@ void Theme::useTheme(ColorTheme theme)
         m_highlightRowColor = QColor(QRgb(0x038e9b));
         m_highlightColumnColor = QColor(QRgb(0x038e9b));
         m_lightStrength = 8.0f;
-        m_ambientStrength = 0.5f;
+        m_ambientStrength = 0.3f;
         m_highlightLightStrength = 10.0f;
         m_uniformColor = false;
         qDebug("ThemeHighContrast");
@@ -283,9 +283,9 @@ void Theme::useTheme(ColorTheme theme)
         m_highlightBarColor = QColor(QRgb(0xf6a625));
         m_highlightRowColor = QColor(QRgb(0x6d5fd5));
         m_highlightColumnColor = QColor(QRgb(0x6d5fd5));
-        m_lightStrength = 3.0f;
-        m_ambientStrength = 0.5f;
-        m_highlightLightStrength = 6.0f;
+        m_lightStrength = 6.0f;
+        m_ambientStrength = 0.3f;
+        m_highlightLightStrength = 7.0f;
         m_uniformColor = true;
         qDebug("ThemeLight");
         break;