Added a separate shader for background

Added api call for setting color scheme
Added api call to set whole data set at once

5 files changed, 171 insertions, 70 deletions

diff --git a/src/datavis3d/engine/q3dbars.cpp b/src/datavis3d/engine/q3dbars.cpp
index a76d8b1c..a35e291b 100644
--- a/src/datavis3d/engine/q3dbars.cpp
+++ b/src/datavis3d/engine/q3dbars.cpp
@@ -49,14 +49,12 @@
 #include <QScreen>
 #include <QMouseEvent>
 
-//#include <qmath.h>
+#include <qmath.h>
 
 #include <QDebug>
 
 QTCOMMERCIALDATAVIS3D_BEGIN_NAMESPACE
 
-const float maxSceneSize = 40.0;
-
 Q3DBars::Q3DBars()
     : d_ptr(new Q3DBarsPrivate(this))
 {
@@ -77,7 +75,16 @@ Q3DBars::~Q3DBars()
 void Q3DBars::initialize()
 {
     // Initialize shaders
-    d_ptr->initShaders(QStringLiteral(":/shaders/vertex"), QStringLiteral(":/shaders/fragment"));
+    if (!d_ptr->m_uniformColor) {
+        d_ptr->initShaders(QStringLiteral(":/shaders/vertex")
+                           , QStringLiteral(":/shaders/fragmentColorOnY"));
+    }
+    else {
+        d_ptr->initShaders(QStringLiteral(":/shaders/vertex")
+                           , QStringLiteral(":/shaders/fragment"));
+    }
+    d_ptr->initBackgroundShaders(QStringLiteral(":/shaders/vertex")
+                                 , QStringLiteral(":/shaders/fragment"));
 
     // Load default mesh
     d_ptr->loadBarMesh();
@@ -125,8 +132,6 @@ void Q3DBars::render()
 
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
-    d_ptr->m_program->bind();
-
     QMatrix4x4 projectionMatrix;
     projectionMatrix.perspective(45.0f, (float)width() / (float)height(), 0.1f, 100.0f);
 
@@ -175,7 +180,9 @@ void Q3DBars::render()
     QVector3D lightPos = QVector3D(0.0f, 1.5f
                                    , (d_ptr->m_sampleCount.y() / 5.0f));
 
-    // TODO: Use a different shader for background?
+    // Bind background shader
+    d_ptr->m_backgroundShader->bind();
+
     // Draw background
     if (d_ptr->m_background) {
         QMatrix4x4 modelMatrix;
@@ -190,31 +197,37 @@ void Q3DBars::render()
         //qDebug() << "modelMatrix" << modelMatrix;
         //qDebug() << "MVPMatrix" << MVPMatrix;
 
-        QVector3D barColor = QVector3D(0.5, 0.5, 0.5);
-
-        d_ptr->m_program->setUniformValue(d_ptr->m_lightPositionUniform, lightPos);
-        d_ptr->m_program->setUniformValue(d_ptr->m_viewMatrixUniform, viewMatrix);
-        d_ptr->m_program->setUniformValue(d_ptr->m_modelMatrixUniform, modelMatrix);
-        d_ptr->m_program->setUniformValue(d_ptr->m_invTransModelMatrixUniform
-                                          , modelMatrix.inverted().transposed());
-        d_ptr->m_program->setUniformValue(d_ptr->m_mvpMatrixUniform, MVPMatrix);
-        d_ptr->m_program->setUniformValue(d_ptr->m_colorUniform, barColor);
-        d_ptr->m_program->setUniformValue(d_ptr->m_lightStrengthUniform, 4.0f);
+        QVector3D backgroundColor = QVector3D(0.5, 0.5, 0.5);
+
+        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_lightPositionUniformBackground
+                                                   , lightPos);
+        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_viewMatrixUniformBackground
+                                                   , viewMatrix);
+        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_modelMatrixUniformBackground
+                                                   , modelMatrix);
+        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_invTransModelMatrixUniformBackground
+                                                   , modelMatrix.inverted().transposed());
+        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_mvpMatrixUniformBackground
+                                                   , MVPMatrix);
+        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_colorUniformBackground
+                                                   , backgroundColor);
+        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_lightStrengthUniformBackground
+                                                   , 4.0f);
 
         // 1st attribute buffer : vertices
         glEnableVertexAttribArray(0);
         glBindBuffer(GL_ARRAY_BUFFER, d_ptr->m_vertexbufferBackground);
-        glVertexAttribPointer(d_ptr->m_positionAttr, 3, GL_FLOAT, GL_TRUE, 0, (void*)0);
+        glVertexAttribPointer(d_ptr->m_positionAttrBackground, 3, GL_FLOAT, GL_TRUE, 0, (void*)0);
 
         // 2nd attribute buffer : normals
         glEnableVertexAttribArray(1);
         glBindBuffer(GL_ARRAY_BUFFER, d_ptr->m_normalbufferBackground);
-        glVertexAttribPointer(d_ptr->m_normalAttr, 3, GL_FLOAT, GL_TRUE, 0, (void*)0);
+        glVertexAttribPointer(d_ptr->m_normalAttrBackground, 3, GL_FLOAT, GL_TRUE, 0, (void*)0);
 
         // 3rd attribute buffer : UVs
         //glEnableVertexAttribArray(2);
         //glBindBuffer(GL_ARRAY_BUFFER, d_ptr->m_uvbufferBackground);
-        //glVertexAttribPointer(d_ptr->m_uvAttr, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
+        //glVertexAttribPointer(d_ptr->m_uvAttrBackground, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
 
         // Index buffer
         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, d_ptr->m_elementbufferBackground);
@@ -227,6 +240,12 @@ void Q3DBars::render()
         //glDisableVertexAttribArray(2);
     }
 
+    // Release background shader
+    d_ptr->m_backgroundShader->release();
+
+    // Bind bar shader
+    d_ptr->m_barShader->bind();
+
     // Draw bars
     for (int row = startRow; row != stopRow; row += stepRow) {
         for (int bar = startBar; bar != stopBar; bar += stepBar) {
@@ -248,19 +267,28 @@ void Q3DBars::render()
             //qDebug() << "modelMatrix" << modelMatrix;
             //qDebug() << "MVPMatrix" << MVPMatrix;
 
-            QVector3D barColor = QVector3D(float(row) / float(d_ptr->m_sampleCount.y())
-                                           , 0
-                                           , barHeight);
-            //QVector3D barColor = QVector3D(0.1, 0.1, 0.5);
-
-            d_ptr->m_program->setUniformValue(d_ptr->m_lightPositionUniform, lightPos);
-            d_ptr->m_program->setUniformValue(d_ptr->m_viewMatrixUniform, viewMatrix);
-            d_ptr->m_program->setUniformValue(d_ptr->m_modelMatrixUniform, modelMatrix);
-            d_ptr->m_program->setUniformValue(d_ptr->m_invTransModelMatrixUniform
-                                              , modelMatrix.inverted().transposed());
-            d_ptr->m_program->setUniformValue(d_ptr->m_mvpMatrixUniform, MVPMatrix);
-            d_ptr->m_program->setUniformValue(d_ptr->m_colorUniform, barColor);
-            d_ptr->m_program->setUniformValue(d_ptr->m_lightStrengthUniform, 4.0f);
+            QVector3D baseColor = QVector3D(d_ptr->m_baseColor.redF()
+                                            , d_ptr->m_baseColor.greenF()
+                                            , d_ptr->m_baseColor.blueF());
+            QVector3D heightColor = QVector3D(d_ptr->m_heightColor.redF()
+                                              , d_ptr->m_heightColor.greenF()
+                                              , d_ptr->m_heightColor.blueF())
+                    * barHeight;
+            QVector3D depthColor = QVector3D(d_ptr->m_depthColor.redF()
+                                             , d_ptr->m_depthColor.greenF()
+                                             , d_ptr->m_depthColor.blueF())
+                    * (float(row) / float(d_ptr->m_sampleCount.y()));
+
+            QVector3D barColor = baseColor + heightColor + depthColor;
+
+            d_ptr->m_barShader->setUniformValue(d_ptr->m_lightPositionUniform, lightPos);
+            d_ptr->m_barShader->setUniformValue(d_ptr->m_viewMatrixUniform, viewMatrix);
+            d_ptr->m_barShader->setUniformValue(d_ptr->m_modelMatrixUniform, modelMatrix);
+            d_ptr->m_barShader->setUniformValue(d_ptr->m_invTransModelMatrixUniform
+                                                , modelMatrix.inverted().transposed());
+            d_ptr->m_barShader->setUniformValue(d_ptr->m_mvpMatrixUniform, MVPMatrix);
+            d_ptr->m_barShader->setUniformValue(d_ptr->m_colorUniform, barColor);
+            d_ptr->m_barShader->setUniformValue(d_ptr->m_lightStrengthUniform, 4.0f);
             //qDebug() << "height:" << barHeight;
 
             // 1st attribute buffer : vertices
@@ -290,7 +318,8 @@ void Q3DBars::render()
         }
     }
 
-    d_ptr->m_program->release();
+    // Release bar shader
+    d_ptr->m_barShader->release();
 }
 
 void Q3DBars::mousePressEvent(QMouseEvent *event)
@@ -377,22 +406,30 @@ void Q3DBars::resizeEvent(QResizeEvent *event)
     // TODO: Handle it
 }
 
-void Q3DBars::addDataSet(QVector<float> data)
+void Q3DBars::addDataRow(const QVector<float> &dataRow)
 {
+    QVector<float> row = dataRow;
     // Check that the input data fits into sample space, and resize if it doesn't
-    if (data.size() > d_ptr->m_sampleCount.x()) {
-        data.resize(d_ptr->m_sampleCount.x());
+    if (row.size() > d_ptr->m_sampleCount.x()) {
+        row.resize(d_ptr->m_sampleCount.x());
         qWarning("Data set too large for sample space");
     }
     // The vector contains data (=height) for each bar, a row at a time
     // With each new row, the previous data set (=row) must be moved back
     // ie. we need as many vectors as we have rows in the sample space
-    d_ptr->m_dataSet.prepend(data);
+    d_ptr->m_dataSet.prepend(row);
     // if the added data pushed us over sample space, remove the oldest data set
     if (d_ptr->m_dataSet.size() > d_ptr->m_sampleCount.y())
         d_ptr->m_dataSet.resize(d_ptr->m_sampleCount.y());
 }
 
+void Q3DBars::addDataSet(const QVector<QVector<float>> &data)
+{
+    d_ptr->m_dataSet.clear();
+    // TODO: Check sizes
+    d_ptr->m_dataSet = data;
+}
+
 void Q3DBars::setBarSpecs(QPointF thickness, QPointF spacing, bool relative)
 {
     d_ptr->m_barThickness = thickness;
@@ -469,23 +506,37 @@ void Q3DBars::setupSampleSpace(QPoint sampleCount)
     for (int rows = 0; rows < sampleCount.y(); rows++) {
         d_ptr->m_dataSet.append(row);
     }
+    // TODO: Invent "idiotproof" max scene size formula..
+    // This seems to work ok if spacing is not negative
+    m_maxSceneSize = 2 * qSqrt(sampleCount.x() * sampleCount.y());
+    //qDebug() << "maxSceneSize" << m_maxSceneSize;
     // Calculate here and at setting bar specs
     d_ptr->calculateSceneScalingFactors();
 }
 
 void Q3DBars::setCameraPosition(float horizontal, float vertical, int distance)
 {
-    d_ptr->m_horizontalRotation = qMin(qMax(horizontal, -180.0f), 180.0f);
-    d_ptr->m_verticalRotation = qMin(qMax(vertical, 0.0f), 90.0f);
-    d_ptr->m_zoomLevel = qMin(qMax(distance, 10), 500);
+    d_ptr->m_horizontalRotation = qBound(-180.0f, horizontal, 180.0f);
+    d_ptr->m_verticalRotation = qBound(0.0f, vertical, 90.0f);
+    d_ptr->m_zoomLevel = qBound(10, distance, 500);
     CameraHelper::setCameraRotation(QPointF(d_ptr->m_horizontalRotation
                                             , d_ptr->m_verticalRotation));
     qDebug() << "camera rotation set to" << d_ptr->m_horizontalRotation << d_ptr->m_verticalRotation;
 }
 
+void Q3DBars::setBarColor(QColor baseColor, QColor heightColor, QColor depthColor, bool uniform)
+{
+    d_ptr->m_baseColor = baseColor;
+    d_ptr->m_heightColor = heightColor;
+    d_ptr->m_depthColor = depthColor;
+    //qDebug() << "colors:" << d_ptr->m_baseColor << d_ptr->m_heightColor << d_ptr->m_depthColor;
+    d_ptr->m_uniformColor = uniform;
+}
+
 Q3DBarsPrivate::Q3DBarsPrivate(Q3DBars *q)
     : q_ptr(q)
-    , m_program(0)
+    , m_barShader(0)
+    , m_backgroundShader(0)
     , m_sampleCount(QPoint(0, 0))
     , m_objFile(QStringLiteral(":/defaultMeshes/bar"))
     , m_vertexCount(0)
@@ -509,6 +560,11 @@ Q3DBarsPrivate::Q3DBarsPrivate(Q3DBars *q)
     , m_scaleFactorX(0)
     , m_scaleFactorZ(0)
     , m_sceneScale(0)
+    , m_maxSceneSize(40.0)
+    , m_baseColor(QColor(Qt::gray))
+    , m_heightColor(QColor(Qt::white))
+    , m_depthColor(QColor(Qt::darkGray))
+    , m_uniformColor(true)
 {
 }
 
@@ -618,24 +674,47 @@ void Q3DBarsPrivate::loadBackgroundMesh()
 
 void Q3DBarsPrivate::initShaders(QString vertexShader, QString fragmentShader)
 {
-    if (m_program)
-        delete m_program;
-    m_program = new QOpenGLShaderProgram(q_ptr);
-    if (!m_program->addShaderFromSourceFile(QOpenGLShader::Vertex, vertexShader))
+    qDebug("initShaders");
+    if (m_barShader)
+        delete m_barShader;
+    m_barShader = new QOpenGLShaderProgram(q_ptr);
+    if (!m_barShader->addShaderFromSourceFile(QOpenGLShader::Vertex, vertexShader))
+        qFatal("Compiling Vertex shader failed");
+    if (!m_barShader->addShaderFromSourceFile(QOpenGLShader::Fragment, fragmentShader))
+        qFatal("Compiling Fragment shader failed");
+    m_barShader->link();
+    m_mvpMatrixUniform = m_barShader->uniformLocation("MVP");
+    m_viewMatrixUniform = m_barShader->uniformLocation("V");
+    m_modelMatrixUniform = m_barShader->uniformLocation("M");
+    m_invTransModelMatrixUniform = m_barShader->uniformLocation("itM");
+    m_positionAttr = m_barShader->attributeLocation("vertexPosition_mdl");
+    m_uvAttr = m_barShader->attributeLocation("vertexUV");
+    m_normalAttr = m_barShader->attributeLocation("vertexNormal_mdl");
+    m_lightPositionUniform = m_barShader->uniformLocation("lightPosition_wrld");
+    m_colorUniform = m_barShader->uniformLocation("color_mdl");
+    m_lightStrengthUniform = m_barShader->uniformLocation("lightStrength");
+}
+
+void Q3DBarsPrivate::initBackgroundShaders(QString vertexShader, QString fragmentShader)
+{
+    if (m_backgroundShader)
+        delete m_backgroundShader;
+    m_backgroundShader = new QOpenGLShaderProgram(q_ptr);
+    if (!m_backgroundShader->addShaderFromSourceFile(QOpenGLShader::Vertex, vertexShader))
         qFatal("Compiling Vertex shader failed");
-    if (!m_program->addShaderFromSourceFile(QOpenGLShader::Fragment, fragmentShader))
+    if (!m_backgroundShader->addShaderFromSourceFile(QOpenGLShader::Fragment, fragmentShader))
         qFatal("Compiling Fragment shader failed");
-    m_program->link();
-    m_mvpMatrixUniform = m_program->uniformLocation("MVP");
-    m_viewMatrixUniform = m_program->uniformLocation("V");
-    m_modelMatrixUniform = m_program->uniformLocation("M");
-    m_invTransModelMatrixUniform = m_program->uniformLocation("itM");
-    m_positionAttr = m_program->attributeLocation("vertexPosition_mdl");
-    m_uvAttr = m_program->attributeLocation("vertexUV");
-    m_normalAttr = m_program->attributeLocation("vertexNormal_mdl");
-    m_lightPositionUniform = m_program->uniformLocation("lightPosition_wrld");
-    m_colorUniform = m_program->uniformLocation("color_mdl");
-    m_lightStrengthUniform = m_program->uniformLocation("lightStrength");
+    m_backgroundShader->link();
+    m_mvpMatrixUniformBackground = m_backgroundShader->uniformLocation("MVP");
+    m_viewMatrixUniformBackground = m_backgroundShader->uniformLocation("V");
+    m_modelMatrixUniformBackground = m_backgroundShader->uniformLocation("M");
+    m_invTransModelMatrixUniformBackground = m_backgroundShader->uniformLocation("itM");
+    m_positionAttrBackground = m_backgroundShader->attributeLocation("vertexPosition_mdl");
+    m_uvAttrBackground = m_backgroundShader->attributeLocation("vertexUV");
+    m_normalAttrBackground = m_backgroundShader->attributeLocation("vertexNormal_mdl");
+    m_lightPositionUniformBackground = m_backgroundShader->uniformLocation("lightPosition_wrld");
+    m_colorUniformBackground = m_backgroundShader->uniformLocation("color_mdl");
+    m_lightStrengthUniformBackground = m_backgroundShader->uniformLocation("lightStrength");
 }
 
 void Q3DBarsPrivate::calculateSceneScalingFactors()
@@ -644,13 +723,13 @@ void Q3DBarsPrivate::calculateSceneScalingFactors()
     m_rowWidth = ((m_sampleCount.x() + 1) * m_barSpacing.x()) / 2.0f;
     m_columnDepth = ((m_sampleCount.y() + 1) * m_barSpacing.y()) / 2.0f;
     m_maxDimension = qMax(m_rowWidth, m_columnDepth);//(m_rowWidth > m_columnDepth) ? m_rowWidth : m_columnDepth;
-    m_scaleX = m_barThickness.x() / m_sampleCount.x() * (maxSceneSize / m_maxDimension);
-    m_scaleZ = m_barThickness.y() / m_sampleCount.x() * (maxSceneSize / m_maxDimension);
+    m_scaleX = m_barThickness.x() / m_sampleCount.x() * (m_maxSceneSize / m_maxDimension);
+    m_scaleZ = m_barThickness.y() / m_sampleCount.x() * (m_maxSceneSize / m_maxDimension);
     m_sceneScale = qMin(m_scaleX, m_scaleZ);//(m_scaleX < m_scaleZ) ? m_scaleX : m_scaleZ;
     float minThickness = qMin(m_barThickness.x(), m_barThickness.y());//(m_barThickness.x() < m_barThickness.y()) ? m_barThickness.x() : m_barThickness.y();
     m_sceneScale = m_sceneScale / minThickness;
-    m_scaleFactorX = m_sampleCount.x() * (m_maxDimension / maxSceneSize);
-    m_scaleFactorZ = m_sampleCount.x() * (m_maxDimension / maxSceneSize);
+    m_scaleFactorX = m_sampleCount.x() * (m_maxDimension / m_maxSceneSize);
+    m_scaleFactorZ = m_sampleCount.x() * (m_maxDimension / m_maxSceneSize);
     qDebug() << "m_scaleX" << m_scaleX << "m_scaleFactorX" << m_scaleFactorX;
     qDebug() << "m_scaleZ" << m_scaleZ << "m_scaleFactorZ" << m_scaleFactorZ;
     qDebug() << "m_rowWidth:" << m_rowWidth << "m_columnDepth:" << m_columnDepth << "m_maxDimension:" << m_maxDimension;
diff --git a/src/datavis3d/engine/q3dbars.h b/src/datavis3d/engine/q3dbars.h
index ff6075d0..4eeaf3e5 100644
--- a/src/datavis3d/engine/q3dbars.h
+++ b/src/datavis3d/engine/q3dbars.h
@@ -29,7 +29,11 @@ public:
     void initialize();
     void render();
 
-    void addDataSet(QVector<float> data);
+    // Add a row of data. Each new row is added to the front of the sample space, moving previous
+    // rows back (if sample space is more than one row deep)
+    void addDataRow(const QVector<float> &dataRow);
+    // Add complete data set at a time, as a vector of data rows
+    void addDataSet(const QVector<QVector<float>> &data);
     // bar thickness, spacing between bars, and is spacing relative to thickness or absolute
     // y -component sets the thickness/spacing of z -direction
     // With relative 0.0f means side-to-side, 1.0f = one thickness in between
@@ -44,8 +48,10 @@ public:
     void setupSampleSpace(QPoint sampleCount);
     // Set camera rotation (in horizontal (-180...180) and vertical (0...90) angles and distance in percentage (10...500))
     void setCameraPosition(float horizontal, float vertical, int distance = 100);
-    // TODO: värien asetus (themet?)
+    // TODO: värien asetus (vai themeillä?). Set uniform to false if you want the (height) color to change from bottom to top
+    void setBarColor(QColor baseColor, QColor heightColor, QColor depthColor, bool uniform = true);
     // TODO: shaderien vaihto (themet?)
+    // TODO: valon siirto / asetus
 
 protected:
     void mousePressEvent(QMouseEvent *event);
diff --git a/src/datavis3d/engine/q3dbars_p.h b/src/datavis3d/engine/q3dbars_p.h
index 1cf22d61..b870fab7 100644
--- a/src/datavis3d/engine/q3dbars_p.h
+++ b/src/datavis3d/engine/q3dbars_p.h
@@ -20,6 +20,7 @@ public:
     void loadBarMesh();
     void loadBackgroundMesh();
     void initShaders(QString vertexShader, QString fragmentShader);
+    void initBackgroundShaders(QString vertexShader, QString fragmentShader);
     void calculateSceneScalingFactors();
 
     GLuint m_positionAttr;
@@ -32,6 +33,16 @@ public:
     GLuint m_mvpMatrixUniform;
     GLuint m_lightPositionUniform;
     GLuint m_lightStrengthUniform;
+    GLuint m_positionAttrBackground;
+    GLuint m_uvAttrBackground;
+    GLuint m_normalAttrBackground;
+    GLuint m_colorUniformBackground;
+    GLuint m_viewMatrixUniformBackground;
+    GLuint m_modelMatrixUniformBackground;
+    GLuint m_invTransModelMatrixUniformBackground;
+    GLuint m_mvpMatrixUniformBackground;
+    GLuint m_lightPositionUniformBackground;
+    GLuint m_lightStrengthUniformBackground;
 
     GLuint m_vertexbuffer;
     GLuint m_uvbuffer;
@@ -44,7 +55,8 @@ public:
 
     Q3DBars *q_ptr;
 
-    QOpenGLShaderProgram *m_program;
+    QOpenGLShaderProgram *m_barShader;
+    QOpenGLShaderProgram *m_backgroundShader;
     QPoint m_sampleCount;
     QString m_objFile;
     int m_vertexCount;
@@ -68,6 +80,12 @@ public:
     float m_scaleFactorX;
     float m_scaleFactorZ;
     float m_sceneScale;
+    float m_maxSceneSize;
+    QColor m_baseColor;
+    QColor m_heightColor;
+    QColor m_depthColor;
+    bool m_uniformColor;
+
 };
 
 QTCOMMERCIALDATAVIS3D_END_NAMESPACE
diff --git a/src/datavis3d/engine/shaders/fragmentShader b/src/datavis3d/engine/shaders/fragmentShader
index 365f653e..01e57fb9 100644
--- a/src/datavis3d/engine/shaders/fragmentShader
+++ b/src/datavis3d/engine/shaders/fragmentShader
@@ -8,7 +8,7 @@ uniform highp vec3 color_mdl;
 uniform highp float lightStrength;
 void main() {
         highp vec3 materialDiffuseColor = color_mdl;
-        highp vec3 materialAmbientColor = vec3(0.5, 0.5, 0.5) * materialDiffuseColor;
+        highp vec3 materialAmbientColor = vec3(0.2, 0.2, 0.2) * materialDiffuseColor;
         highp vec3 materialSpecularColor = vec3(1.0, 1.0, 1.0);
 	highp float distance = length(lightPosition_wrld - position_wrld);
 	highp vec3 n = normalize(normal_cmr);
diff --git a/src/datavis3d/engine/shaders/fragmentShaderColorOnY b/src/datavis3d/engine/shaders/fragmentShaderColorOnY
index b212aca5..43ede08e 100644
--- a/src/datavis3d/engine/shaders/fragmentShaderColorOnY
+++ b/src/datavis3d/engine/shaders/fragmentShaderColorOnY
@@ -8,10 +8,8 @@ uniform highp vec3 lightPosition_wrld;
 uniform highp vec3 color_mdl;
 uniform highp float lightStrength;
 void main() {
-        //highp vec3 materialDiffuseColor = vec3(coords_mdl.y, coords_mdl.y, coords_mdl.y) * color_mdl;
-        highp vec3 materialDiffuseColor = vec3(coords_mdl.y * color_mdl.y, coords_mdl.y * color_mdl.z, coords_mdl.y * color_mdl.x);
-        //highp vec3 materialDiffuseColor = vec3(position_wrld.y, 0.2, position_wrld.y);
-        highp vec3 materialAmbientColor = vec3(0.5, 0.5, 0.5) * materialDiffuseColor;
+        highp vec3 materialDiffuseColor = vec3(coords_mdl.y * color_mdl.x, coords_mdl.y * color_mdl.y, coords_mdl.y * color_mdl.z);
+        highp vec3 materialAmbientColor = vec3(0.2, 0.2, 0.2) * materialDiffuseColor;
         highp vec3 materialSpecularColor = vec3(1.0, 1.0, 1.0);
 	highp float distance = length(lightPosition_wrld - position_wrld);
 	highp vec3 n = normalize(normal_cmr);