Shader loading moved to a generic helper class that can be used from other visualizers too

5 files changed, 398 insertions, 125 deletions

diff --git a/src/datavis3d/engine/q3dbars.cpp b/src/datavis3d/engine/q3dbars.cpp
index af1493d7..87bdc9c1 100644
--- a/src/datavis3d/engine/q3dbars.cpp
+++ b/src/datavis3d/engine/q3dbars.cpp
@@ -44,9 +44,9 @@
 #include "vertexindexer_p.h"
 #include "camerahelper_p.h"
 #include "sampledata_p.h"
+#include "shaderhelper_p.h"
 
 #include <QMatrix4x4>
-#include <QOpenGLShaderProgram>
 #include <QOpenGLPaintDevice>
 #include <QPainter>
 #include <QScreen>
@@ -98,7 +98,7 @@ void Q3DBars::initialize()
     d_ptr->loadBackgroundMesh();
 
     // Set clear color
-    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+    glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
 
     // Set OpenGL features
     glEnable(GL_DEPTH_TEST);
@@ -260,16 +260,16 @@ void Q3DBars::drawScene()
                                            , (float)(bar + 2) / (float)(d_ptr->m_sampleCount.x() + 2)
                                            , 0.0f);
 
-            d_ptr->m_selectionShader->setUniformValue(d_ptr->m_mvpMatrixUniformSelection
+            d_ptr->m_selectionShader->setUniformValue(d_ptr->m_selectionShader->MVP()
                                                       , MVPMatrix);
-            d_ptr->m_selectionShader->setUniformValue(d_ptr->m_colorUniformSelection
+            d_ptr->m_selectionShader->setUniformValue(d_ptr->m_selectionShader->color()
                                                       , barColor);
 
 #ifdef USE_HAX0R_SELECTION
             // 1st attribute buffer : vertices
-            glEnableVertexAttribArray(d_ptr->m_positionAttrSelection);
+            glEnableVertexAttribArray(d_ptr->m_selectionShader->posAtt());
             glBindBuffer(GL_ARRAY_BUFFER, d_ptr->m_vertexbuffer);
-            glVertexAttribPointer(d_ptr->m_positionAttrSelection
+            glVertexAttribPointer(d_ptr->m_selectionShader->posAtt()
                                   , 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
 
             // Index buffer
@@ -282,15 +282,15 @@ void Q3DBars::drawScene()
             glBindBuffer(GL_ARRAY_BUFFER, 0);
             glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 
-            glDisableVertexAttribArray(d_ptr->m_positionAttrSelection);
+            glDisableVertexAttribArray(d_ptr->m_selectionShader->posAtt());
 #else // TODO: fix this - doesn't work yet
             glBindFramebuffer(GL_FRAMEBUFFER, d_ptr->m_framebufferSelection);
             //glReadBuffer(GL_COLOR_ATTACHMENT0);
 
             // 1st attribute buffer : vertices
-            glEnableVertexAttribArray(d_ptr->m_positionAttrSelection);
+            glEnableVertexAttribArray(d_ptr->m_selectionShader->posAtt());
             glBindBuffer(GL_ARRAY_BUFFER, d_ptr->m_vertexbuffer);
-            glVertexAttribPointer(d_ptr->m_positionAttrSelection
+            glVertexAttribPointer(d_ptr->m_selectionShader->posAtt()
                                   , 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
 
             // Index buffer
@@ -300,7 +300,7 @@ void Q3DBars::drawScene()
             GLenum DrawBuffers[1] = {GL_COLOR_ATTACHMENT0};
             glDrawElements(GL_TRIANGLES, d_ptr->m_indexCount, GL_UNSIGNED_SHORT, DrawBuffers);
 
-            glDisableVertexAttribArray(d_ptr->m_positionAttrSelection);
+            glDisableVertexAttribArray(d_ptr->m_selectionShader->posAtt());
 
             // Free buffers
             glBindBuffer(GL_ARRAY_BUFFER, 0);
@@ -369,35 +369,38 @@ void Q3DBars::drawScene()
 
         QVector3D backgroundColor = QVector3D(0.75, 0.75, 0.75);
 
-        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_lightPositionUniformBackground
+        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_backgroundShader->lightP()
                                                    , lightPos);
-        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_viewMatrixUniformBackground
+        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_backgroundShader->view()
                                                    , viewMatrix);
-        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_modelMatrixUniformBackground
+        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_backgroundShader->model()
                                                    , modelMatrix);
-        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_invTransModelMatrixUniformBackground
+        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_backgroundShader->nModel()
                                                    , modelMatrix.inverted().transposed());
-        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_mvpMatrixUniformBackground
+        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_backgroundShader->MVP()
                                                    , MVPMatrix);
-        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_colorUniformBackground
+        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_backgroundShader->color()
                                                    , backgroundColor);
-        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_lightStrengthUniformBackground
-                                                   , 4.0f);
+        d_ptr->m_backgroundShader->setUniformValue(d_ptr->m_backgroundShader->lightS()
+                                                   , 6.0f);
 
         // 1st attribute buffer : vertices
-        glEnableVertexAttribArray(d_ptr->m_positionAttrBackground);
+        glEnableVertexAttribArray(d_ptr->m_backgroundShader->posAtt());
         glBindBuffer(GL_ARRAY_BUFFER, d_ptr->m_vertexbufferBackground);
-        glVertexAttribPointer(d_ptr->m_positionAttrBackground, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
+        glVertexAttribPointer(d_ptr->m_backgroundShader->posAtt()
+                              , 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
 
         // 2nd attribute buffer : normals
-        glEnableVertexAttribArray(d_ptr->m_normalAttrBackground);
+        glEnableVertexAttribArray(d_ptr->m_backgroundShader->normalAtt());
         glBindBuffer(GL_ARRAY_BUFFER, d_ptr->m_normalbufferBackground);
-        glVertexAttribPointer(d_ptr->m_normalAttrBackground, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
+        glVertexAttribPointer(d_ptr->m_backgroundShader->normalAtt()
+                              , 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
 
         // 3rd attribute buffer : UVs
-        //glEnableVertexAttribArray(d_ptr->m_uvAttrBackground);
+        //glEnableVertexAttribArray(d_ptr->m_backgroundShader->uvAtt());
         //glBindBuffer(GL_ARRAY_BUFFER, d_ptr->m_uvbufferBackground);
-        //glVertexAttribPointer(d_ptr->m_uvAttrBackground, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
+        //glVertexAttribPointer(d_ptr->m_backgroundShader->uvAtt()
+        //                      , 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
 
         // Index buffer
         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, d_ptr->m_elementbufferBackground);
@@ -409,9 +412,9 @@ void Q3DBars::drawScene()
         glBindBuffer(GL_ARRAY_BUFFER, 0);
         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 
-        //glDisableVertexAttribArray(d_ptr->m_uvAttrBackground);
-        glDisableVertexAttribArray(d_ptr->m_normalAttrBackground);
-        glDisableVertexAttribArray(d_ptr->m_positionAttrBackground);
+        //glDisableVertexAttribArray(d_ptr->m_backgroundShader->uvAtt());
+        glDisableVertexAttribArray(d_ptr->m_backgroundShader->normalAtt());
+        glDisableVertexAttribArray(d_ptr->m_backgroundShader->posAtt());
     }
 
     // Release background shader
@@ -455,7 +458,7 @@ void Q3DBars::drawScene()
 
             QVector3D barColor = baseColor + heightColor + depthColor;
 
-            float lightStrength = 5.0f;
+            float lightStrength = 6.0f;
             if (d_ptr->m_selectionMode > None) {
                 Q3DBarsPrivate::SelectionType selectionType = d_ptr->isSelected(row, bar
                                                                                 , selection);
@@ -502,30 +505,33 @@ void Q3DBars::drawScene()
             //}
             //barIndex++; // TODO: Remove when done debugging
 
-            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
+            d_ptr->m_barShader->setUniformValue(d_ptr->m_barShader->lightP(), lightPos);
+            d_ptr->m_barShader->setUniformValue(d_ptr->m_barShader->view(), viewMatrix);
+            d_ptr->m_barShader->setUniformValue(d_ptr->m_barShader->model(), modelMatrix);
+            d_ptr->m_barShader->setUniformValue(d_ptr->m_barShader->nModel()
                                                 , 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, lightStrength);
+            d_ptr->m_barShader->setUniformValue(d_ptr->m_barShader->MVP(), MVPMatrix);
+            d_ptr->m_barShader->setUniformValue(d_ptr->m_barShader->color(), barColor);
+            d_ptr->m_barShader->setUniformValue(d_ptr->m_barShader->lightS(), lightStrength);
             //qDebug() << "height:" << barHeight;
 
             // 1st attribute buffer : vertices
-            glEnableVertexAttribArray(d_ptr->m_positionAttr);
+            glEnableVertexAttribArray(d_ptr->m_barShader->posAtt());
             glBindBuffer(GL_ARRAY_BUFFER, d_ptr->m_vertexbuffer);
-            glVertexAttribPointer(d_ptr->m_positionAttr, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
+            glVertexAttribPointer(d_ptr->m_barShader->posAtt()
+                                  , 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
 
             // 2nd attribute buffer : normals
-            glEnableVertexAttribArray(d_ptr->m_normalAttr);
+            glEnableVertexAttribArray(d_ptr->m_barShader->normalAtt());
             glBindBuffer(GL_ARRAY_BUFFER, d_ptr->m_normalbuffer);
-            glVertexAttribPointer(d_ptr->m_normalAttr, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
+            glVertexAttribPointer(d_ptr->m_barShader->normalAtt()
+                                  , 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
 
             // 3rd attribute buffer : UVs
-            //glEnableVertexAttribArray(d_ptr->m_uvAttr);
+            //glEnableVertexAttribArray(d_ptr->m_barShader->m_uvAtt());
             //glBindBuffer(GL_ARRAY_BUFFER, d_ptr->m_uvbuffer);
-            //glVertexAttribPointer(d_ptr->m_uvAttr, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
+            //glVertexAttribPointer(d_ptr->m_barShader->m_uvAtt()
+            //                      , 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
 
             // Index buffer
             glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, d_ptr->m_elementbuffer);
@@ -537,9 +543,9 @@ void Q3DBars::drawScene()
             glBindBuffer(GL_ARRAY_BUFFER, 0);
             glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 
-            //glDisableVertexAttribArray(d_ptr->m_uvAttr);
-            glDisableVertexAttribArray(d_ptr->m_normalAttr);
-            glDisableVertexAttribArray(d_ptr->m_positionAttr);
+            //glDisableVertexAttribArray(d_ptr->m_barShader->m_uvAtt());
+            glDisableVertexAttribArray(d_ptr->m_barShader->normalAtt());
+            glDisableVertexAttribArray(d_ptr->m_barShader->posAtt());
         }
     }
     if (!barSelectionFound) {
@@ -956,37 +962,17 @@ void Q3DBarsPrivate::initShaders(const QString &vertexShader, const QString &fra
 {
     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");
+    m_barShader = new ShaderHelper(q_ptr, vertexShader, fragmentShader);
+    m_barShader->initialize();
 }
 
 void Q3DBarsPrivate::initSelectionShader()
 {
-    m_selectionShader = new QOpenGLShaderProgram(q_ptr);
-    if (!m_selectionShader->addShaderFromSourceFile(QOpenGLShader::Vertex
-                                                    , QStringLiteral(":/shaders/vertexSelection")))
-        qFatal("Compiling Vertex shader failed");
-    if (!m_selectionShader->addShaderFromSourceFile(QOpenGLShader::Fragment
-                                                    , QStringLiteral(":/shaders/fragmentSelection")))
-        qFatal("Compiling Fragment shader failed");
-    m_selectionShader->link();
-    m_mvpMatrixUniformSelection = m_selectionShader->uniformLocation("MVP");
-    m_colorUniformSelection = m_selectionShader->uniformLocation("color_mdl");
-    m_positionAttrSelection = m_selectionShader->attributeLocation("vertexPosition_mdl");
+    if (m_selectionShader)
+        delete m_selectionShader;
+    m_selectionShader = new ShaderHelper(q_ptr, QStringLiteral(":/shaders/vertexSelection")
+                                         , QStringLiteral(":/shaders/fragmentSelection"));
+    m_selectionShader->initialize();
 }
 
 void Q3DBarsPrivate::initSelectionBuffer()
@@ -1031,22 +1017,8 @@ void Q3DBarsPrivate::initBackgroundShaders(const QString &vertexShader
 {
     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_backgroundShader->addShaderFromSourceFile(QOpenGLShader::Fragment, fragmentShader))
-        qFatal("Compiling Fragment shader failed");
-    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");
+    m_backgroundShader = new ShaderHelper(q_ptr, vertexShader, fragmentShader);
+    m_backgroundShader->initialize();
 }
 
 void Q3DBarsPrivate::calculateSceneScalingFactors()
@@ -1071,8 +1043,8 @@ void Q3DBarsPrivate::calculateSceneScalingFactors()
 Q3DBarsPrivate::SelectionType Q3DBarsPrivate::isSelected(int row, int bar, const QVector3D &selection)
 {
     SelectionType isSelectedType = None;
-    if (selection == QVector3D(0, 0, 0))
-        return isSelectedType; // skip background (= black)
+    if (selection == QVector3D(0.1f, 0.1f, 0.1f))
+        return isSelectedType; // skip background
     QVector3D current = QVector3D((GLubyte)(((float)(row + 2) / (float)(m_sampleCount.y() + 2))
                                             * 255 + 0.49) // add 0.49 to fix rounding
                                   , (GLubyte)(((float)(bar + 2) / (float)(m_sampleCount.x() + 2))
diff --git a/src/datavis3d/engine/q3dbars_p.h b/src/datavis3d/engine/q3dbars_p.h
index 8aedf8f3..302d473b 100644
--- a/src/datavis3d/engine/q3dbars_p.h
+++ b/src/datavis3d/engine/q3dbars_p.h
@@ -5,7 +5,6 @@
 #include <QOpenGLFunctions>
 
 class QOpenGLPaintDevice;
-class QOpenGLShaderProgram;
 class QPoint;
 class QPointF;
 
@@ -13,6 +12,7 @@ QTCOMMERCIALDATAVIS3D_BEGIN_NAMESPACE
 
 class Q3DBars;
 class SampleData;
+class ShaderHelper;
 
 class Q3DBarsPrivate
 {
@@ -37,32 +37,6 @@ public:
     void calculateSceneScalingFactors();
     SelectionType isSelected(int row, int bar, const QVector3D &selection);
 
-    GLuint m_positionAttr;
-    GLuint m_uvAttr;
-    GLuint m_normalAttr;
-    GLuint m_colorUniform;
-    GLuint m_viewMatrixUniform;
-    GLuint m_modelMatrixUniform;
-    GLuint m_invTransModelMatrixUniform;
-    GLuint m_mvpMatrixUniform;
-    GLuint m_lightPositionUniform;
-    GLuint m_lightStrengthUniform;
-
-    GLuint m_positionAttrSelection;
-    GLuint m_mvpMatrixUniformSelection;
-    GLuint m_colorUniformSelection;
-
-    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;
     GLuint m_normalbuffer;
@@ -81,9 +55,9 @@ public:
     Q3DBars *q_ptr;
 
     QOpenGLPaintDevice *m_paintDevice;
-    QOpenGLShaderProgram *m_barShader;
-    QOpenGLShaderProgram *m_selectionShader;
-    QOpenGLShaderProgram *m_backgroundShader;
+    ShaderHelper *m_barShader;
+    ShaderHelper *m_selectionShader;
+    ShaderHelper *m_backgroundShader;
     QPoint m_sampleCount;
     QString m_objFile;
     int m_indexCount;
diff --git a/src/datavis3d/utils/shaderhelper.cpp b/src/datavis3d/utils/shaderhelper.cpp
new file mode 100644
index 00000000..8193692f
--- /dev/null
+++ b/src/datavis3d/utils/shaderhelper.cpp
@@ -0,0 +1,207 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+**     of its contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "shaderhelper_p.h"
+
+#include <QOpenGLShader>
+
+QTCOMMERCIALDATAVIS3D_BEGIN_NAMESPACE
+
+ShaderHelper::ShaderHelper(QObject *parent
+                           , const QString &vertexShader
+                           , const QString &fragmentShader
+                           , const QString &texture
+                           , const QString &depthTexture)
+    : m_caller(parent)
+    , m_program(0)
+    , m_vertexShaderFile(vertexShader)
+    , m_fragmentShaderFile(fragmentShader)
+    , m_textureFile(texture)
+    , m_depthTextureFile(depthTexture)
+{
+}
+
+ShaderHelper::~ShaderHelper()
+{
+    delete m_program;
+}
+
+void ShaderHelper::setShaders(const QString &vertexShader
+                              , const QString &fragmentShader)
+{
+    m_vertexShaderFile = vertexShader;
+    m_fragmentShaderFile = fragmentShader;
+}
+
+void ShaderHelper::setTextures(const QString &texture
+                               , const QString &depthTexture)
+{
+    m_textureFile = texture;
+    m_depthTextureFile = depthTexture;
+}
+
+void ShaderHelper::initialize()
+{
+    if (m_program)
+        delete m_program;
+    m_program = new QOpenGLShaderProgram(m_caller);
+    if (!m_program->addShaderFromSourceFile(QOpenGLShader::Vertex, m_vertexShaderFile))
+        qFatal("Compiling Vertex shader failed");
+    if (!m_program->addShaderFromSourceFile(QOpenGLShader::Fragment, m_fragmentShaderFile))
+        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_lightPositionUniform = m_program->uniformLocation("lightPosition_wrld");
+    m_lightStrengthUniform = m_program->uniformLocation("lightStrength");
+    m_colorUniform = m_program->uniformLocation("color_mdl");
+
+    m_positionAttr = m_program->attributeLocation("vertexPosition_mdl");
+    m_uvAttr = m_program->attributeLocation("vertexUV");
+    m_normalAttr = m_program->attributeLocation("vertexNormal_mdl");
+
+    m_initialized = true;
+}
+
+void ShaderHelper::bind()
+{
+    m_program->bind();
+}
+
+void ShaderHelper::release()
+{
+    m_program->release();
+}
+
+void ShaderHelper::setUniformValue(GLuint uniform, const QVector3D &value)
+{
+    m_program->setUniformValue(uniform, value);
+}
+
+void ShaderHelper::setUniformValue(GLuint uniform, const QVector4D &value)
+{
+    m_program->setUniformValue(uniform, value);
+}
+
+void ShaderHelper::setUniformValue(GLuint uniform, const QMatrix4x4 &value)
+{
+    m_program->setUniformValue(uniform, value);
+}
+
+void ShaderHelper::setUniformValue(GLuint uniform, GLfloat value)
+{
+    m_program->setUniformValue(uniform, value);
+}
+
+GLuint ShaderHelper::MVP()
+{
+    if (!m_initialized)
+        qFatal("Shader not initialized");
+    return m_mvpMatrixUniform;
+}
+
+GLuint ShaderHelper::view()
+{
+    if (!m_initialized)
+        qFatal("Shader not initialized");
+    return m_viewMatrixUniform;
+}
+
+GLuint ShaderHelper::model()
+{
+    if (!m_initialized)
+        qFatal("Shader not initialized");
+    return m_modelMatrixUniform;
+}
+
+GLuint ShaderHelper::nModel()
+{
+    if (!m_initialized)
+        qFatal("Shader not initialized");
+    return m_invTransModelMatrixUniform;
+}
+
+GLuint ShaderHelper::lightP()
+{
+    if (!m_initialized)
+        qFatal("Shader not initialized");
+    return m_lightPositionUniform;
+}
+
+GLuint ShaderHelper::lightS()
+{
+    if (!m_initialized)
+        qFatal("Shader not initialized");
+    return m_lightStrengthUniform;
+}
+
+GLuint ShaderHelper::color()
+{
+    if (!m_initialized)
+        qFatal("Shader not initialized");
+    return m_colorUniform;
+}
+
+GLuint ShaderHelper::posAtt()
+{
+    if (!m_initialized)
+        qFatal("Shader not initialized");
+    return m_positionAttr;
+}
+
+GLuint ShaderHelper::uvAtt()
+{
+    if (!m_initialized)
+        qFatal("Shader not initialized");
+    return m_uvAttr;
+}
+
+GLuint ShaderHelper::normalAtt()
+{
+    if (!m_initialized)
+        qFatal("Shader not initialized");
+    return m_normalAttr;
+}
+
+// TODO: Add texture stuff
+
+QTCOMMERCIALDATAVIS3D_END_NAMESPACE
diff --git a/src/datavis3d/utils/shaderhelper_p.h b/src/datavis3d/utils/shaderhelper_p.h
new file mode 100644
index 00000000..fc9d1b7c
--- /dev/null
+++ b/src/datavis3d/utils/shaderhelper_p.h
@@ -0,0 +1,116 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the QtXmlPatterns module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef SHADERHELPER_P_H
+#define SHADERHELPER_P_H
+
+#include "qdatavis3dglobal.h"
+#include <QOpenGLFunctions>
+
+class QOpenGLShaderProgram;
+//class QObject;
+
+QTCOMMERCIALDATAVIS3D_BEGIN_NAMESPACE
+
+class ShaderHelper
+{
+    public:
+    ShaderHelper(QObject *parent
+                 , const QString &vertexShader = QString()
+                 , const QString &fragmentShader = QString()
+                 , const QString &texture = QString()
+                 , const QString &depthTexture = QString());
+    ~ShaderHelper();
+
+    void setShaders(const QString &vertexShader, const QString &fragmentShader);
+    void setTextures(const QString &texture, const QString &depthTexture);
+
+    void initialize();
+    void bind();
+    void release();
+    void setUniformValue(GLuint uniform, const QVector3D &value);
+    void setUniformValue(GLuint uniform, const QVector4D &value);
+    void setUniformValue(GLuint uniform, const QMatrix4x4 &value);
+    void setUniformValue(GLuint uniform, GLfloat value);
+
+    GLuint MVP();
+    GLuint view();
+    GLuint model();
+    GLuint nModel();
+    GLuint lightP();
+    GLuint lightS();
+    GLuint color();
+
+    GLuint posAtt();
+    GLuint uvAtt();
+    GLuint normalAtt();
+
+    private:
+    QObject *m_caller;
+    QOpenGLShaderProgram *m_program;
+
+    QString m_vertexShaderFile;
+    QString m_fragmentShaderFile;
+
+    QString m_textureFile;
+    QString m_depthTextureFile;
+
+    GLuint m_positionAttr;
+    GLuint m_uvAttr;
+    GLuint m_normalAttr;
+
+    GLuint m_colorUniform;
+    GLuint m_viewMatrixUniform;
+    GLuint m_modelMatrixUniform;
+    GLuint m_invTransModelMatrixUniform;
+    GLuint m_mvpMatrixUniform;
+    GLuint m_lightPositionUniform;
+    GLuint m_lightStrengthUniform;
+
+    GLuint m_texture;
+    GLuint m_depthTexture;
+
+    GLboolean m_initialized;
+};
+
+QTCOMMERCIALDATAVIS3D_END_NAMESPACE
+
+#endif
diff --git a/src/datavis3d/utils/utils.pri b/src/datavis3d/utils/utils.pri
index c62340d1..edacd877 100644
--- a/src/datavis3d/utils/utils.pri
+++ b/src/datavis3d/utils/utils.pri
@@ -1,7 +1,11 @@
-HEADERS += $$PWD/meshloader_p.h   \
-           $$PWD/vertexindexer_p.h  \
-           $$PWD/camerahelper_p.h
+HEADERS += $$PWD/meshloader_p.h \
+           $$PWD/vertexindexer_p.h \
+           $$PWD/camerahelper_p.h \
+           $$PWD/shaderhelper_p.h #\
+           #$$PWD/objecthelper_p.h
 
-SOURCES += $$PWD/meshloader.cpp   \
-           $$PWD/vertexindexer.cpp  \
-           $$PWD/camerahelper.cpp
+SOURCES += $$PWD/meshloader.cpp \
+           $$PWD/vertexindexer.cpp \
+           $$PWD/camerahelper.cpp \
+           $$PWD/shaderhelper.cpp #\
+           #$$PWD/objecthelper.cpp