15 files changed, 602 insertions, 760 deletions
diff --git a/src/render/graphicshelpers/graphicscontext.cpp b/src/render/graphicshelpers/graphicscontext.cpp
index acec8edf6..4c2d902f1 100644
--- a/src/render/graphicshelpers/graphicscontext.cpp
+++ b/src/render/graphicshelpers/graphicscontext.cpp
@@ -852,6 +852,11 @@ void GraphicsContext::alphaTest(GLenum mode1, GLenum mode2)
     m_glHelper->alphaTest(mode1, mode2);
 }
 
+void GraphicsContext::bindFramebuffer(GLuint fbo)
+{
+    m_glHelper->bindFrameBufferObject(fbo);
+}
+
 void GraphicsContext::depthTest(GLenum mode)
 {
     m_glHelper->depthTest(mode);
@@ -874,11 +879,6 @@ void GraphicsContext::bindFragOutputs(GLuint shader, const QHash<QString, int> &
         m_glHelper->bindFragDataLocation(shader, outputs);
 }
 
-void GraphicsContext::bindUniform(const QVariant &v, const ShaderUniform &description)
-{
-    m_glHelper->bindUniform(v, description);
-}
-
 void GraphicsContext::bindUniformBlock(GLuint programId, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
 {
     m_glHelper->bindUniformBlock(programId, uniformBlockIndex, uniformBlockBinding);
@@ -1079,12 +1079,12 @@ void GraphicsContext::setParameters(ShaderParameterPack &parameterPack)
     for (int i = 0; i < parameterPack.textures().size(); ++i) {
         const ShaderParameterPack::NamedTexture &namedTex = parameterPack.textures().at(i);
         Texture *t = manager->lookupResource<Texture, TextureManager>(namedTex.texId);
-        // TO DO : Rework the way textures are loaded
         if (t != nullptr) {
             int texUnit = activateTexture(TextureScopeMaterial, t);
             if (uniformValues.contains(namedTex.glslNameId)) {
-                QUniformValue &texUniform = uniformValues[namedTex.glslNameId];
-                texUniform.setTextureUnit(texUnit);
+                UniformValue &texUniform = uniformValues[namedTex.glslNameId];
+                Q_ASSERT(texUniform.valueType() == UniformValue::TextureValue);
+                texUniform.data<UniformValue::Texture>()->textureId = texUnit;
             }
         }
     }
@@ -1140,8 +1140,7 @@ void GraphicsContext::setParameters(ShaderParameterPack &parameterPack)
     for (const ShaderUniform &uniform : activeUniforms) {
         // We can use [] as we are sure the the uniform wouldn't
         // be un activeUniforms if there wasn't a matching value
-        const QUniformValue &value = values[uniform.m_nameId];
-        value.apply(this, uniform);
+        applyUniform(uniform, values[uniform.m_nameId]);
     }
 }
 
@@ -1171,6 +1170,109 @@ void GraphicsContext::disableAttribute(const GraphicsContext::VAOVertexAttribute
     prog->disableAttributeArray(attr.location);
 }
 
+void GraphicsContext::applyUniform(const ShaderUniform &description, const UniformValue &v)
+{
+    const UniformType type = m_glHelper->uniformTypeFromGLType(description.m_type);
+
+    switch (type) {
+    case UniformType::Float:
+        applyUniformHelper<UniformType::Float>(description.m_location, v);
+        break;
+    case UniformType::Vec2:
+        applyUniformHelper<UniformType::Vec2>(description.m_location, v);
+        break;
+    case UniformType::Vec3:
+        applyUniformHelper<UniformType::Vec3>(description.m_location, v);
+        break;
+    case UniformType::Vec4:
+        applyUniformHelper<UniformType::Vec4>(description.m_location, v);
+        break;
+
+    case UniformType::Double:
+        applyUniformHelper<UniformType::Double>(description.m_location, v);
+        break;
+    case UniformType::DVec2:
+        applyUniformHelper<UniformType::DVec2>(description.m_location, v);
+        break;
+    case UniformType::DVec3:
+        applyUniformHelper<UniformType::DVec3>(description.m_location, v);
+        break;
+    case UniformType::DVec4:
+        applyUniformHelper<UniformType::DVec4>(description.m_location, v);
+        break;
+
+    case UniformType::Sampler:
+    case UniformType::Int:
+        applyUniformHelper<UniformType::Int>(description.m_location, v);
+        break;
+    case UniformType::IVec2:
+        applyUniformHelper<UniformType::IVec2>(description.m_location, v);
+        break;
+    case UniformType::IVec3:
+        applyUniformHelper<UniformType::IVec3>(description.m_location, v);
+        break;
+    case UniformType::IVec4:
+        applyUniformHelper<UniformType::IVec4>(description.m_location, v);
+        break;
+
+    case UniformType::UInt:
+        applyUniformHelper<UniformType::Int>(description.m_location, v);
+        break;
+    case UniformType::UIVec2:
+        applyUniformHelper<UniformType::IVec2>(description.m_location, v);
+        break;
+    case UniformType::UIVec3:
+        applyUniformHelper<UniformType::IVec3>(description.m_location, v);
+        break;
+    case UniformType::UIVec4:
+        applyUniformHelper<UniformType::IVec4>(description.m_location, v);
+        break;
+
+    case UniformType::Bool:
+        applyUniformHelper<UniformType::Bool>(description.m_location, v);
+        break;
+    case UniformType::BVec2:
+        applyUniformHelper<UniformType::BVec2>(description.m_location, v);
+        break;
+    case UniformType::BVec3:
+        applyUniformHelper<UniformType::BVec3>(description.m_location, v);
+        break;
+    case UniformType::BVec4:
+        applyUniformHelper<UniformType::BVec4>(description.m_location, v);
+        break;
+
+    case UniformType::Mat2:
+        applyUniformHelper<UniformType::Mat2>(description.m_location, v);
+        break;
+    case UniformType::Mat3:
+        applyUniformHelper<UniformType::Mat3>(description.m_location, v);
+        break;
+    case UniformType::Mat4:
+        applyUniformHelper<UniformType::Mat4>(description.m_location, v);
+        break;
+    case UniformType::Mat2x3:
+        applyUniformHelper<UniformType::Mat2x3>(description.m_location, v);
+        break;
+    case UniformType::Mat3x2:
+        applyUniformHelper<UniformType::Mat3x2>(description.m_location, v);
+        break;
+    case UniformType::Mat2x4:
+        applyUniformHelper<UniformType::Mat2x4>(description.m_location, v);
+        break;
+    case UniformType::Mat4x2:
+        applyUniformHelper<UniformType::Mat4x2>(description.m_location, v);
+    case UniformType::Mat3x4:
+        applyUniformHelper<UniformType::Mat3x4>(description.m_location, v);
+        break;
+    case UniformType::Mat4x3:
+        applyUniformHelper<UniformType::Mat4x3>(description.m_location, v);
+        break;
+
+    default:
+        break;
+    }
+}
+
 // Note: needs to be called while VAO is bound
 void GraphicsContext::specifyAttribute(const Attribute *attribute, Buffer *buffer, int location)
 {
@@ -1452,6 +1554,37 @@ QImage GraphicsContext::readFramebuffer(QSize size)
     return qt_gl_read_framebuffer(size, true, true);
 }
 
+QT3D_UNIFORM_TYPE_IMPL(UniformType::Float, float, glUniform1fv)
+QT3D_UNIFORM_TYPE_IMPL(UniformType::Vec2, float, glUniform2fv)
+QT3D_UNIFORM_TYPE_IMPL(UniformType::Vec3, float, glUniform3fv)
+QT3D_UNIFORM_TYPE_IMPL(UniformType::Vec4, float, glUniform4fv)
+
+// OpenGL expects int* as values for booleans
+QT3D_UNIFORM_TYPE_IMPL(UniformType::Bool, int, glUniform1iv)
+QT3D_UNIFORM_TYPE_IMPL(UniformType::BVec2, int, glUniform2iv)
+QT3D_UNIFORM_TYPE_IMPL(UniformType::BVec3, int, glUniform3iv)
+QT3D_UNIFORM_TYPE_IMPL(UniformType::BVec4, int, glUniform4iv)
+
+QT3D_UNIFORM_TYPE_IMPL(UniformType::Int, int, glUniform1iv)
+QT3D_UNIFORM_TYPE_IMPL(UniformType::IVec2, int, glUniform2iv)
+QT3D_UNIFORM_TYPE_IMPL(UniformType::IVec3, int, glUniform3iv)
+QT3D_UNIFORM_TYPE_IMPL(UniformType::IVec4, int, glUniform4iv)
+
+QT3D_UNIFORM_TYPE_IMPL(UniformType::UInt, uint, glUniform1uiv)
+QT3D_UNIFORM_TYPE_IMPL(UniformType::UIVec2, uint, glUniform2uiv)
+QT3D_UNIFORM_TYPE_IMPL(UniformType::UIVec3, uint, glUniform3uiv)
+QT3D_UNIFORM_TYPE_IMPL(UniformType::UIVec4, uint, glUniform4uiv)
+
+QT3D_UNIFORM_TYPE_IMPL(UniformType::Mat2, float, glUniformMatrix2fv)
+QT3D_UNIFORM_TYPE_IMPL(UniformType::Mat3, float, glUniformMatrix3fv)
+QT3D_UNIFORM_TYPE_IMPL(UniformType::Mat4, float, glUniformMatrix4fv)
+QT3D_UNIFORM_TYPE_IMPL(UniformType::Mat2x3, float, glUniformMatrix2x3fv)
+QT3D_UNIFORM_TYPE_IMPL(UniformType::Mat3x2, float, glUniformMatrix3x2fv)
+QT3D_UNIFORM_TYPE_IMPL(UniformType::Mat2x4, float, glUniformMatrix2x4fv)
+QT3D_UNIFORM_TYPE_IMPL(UniformType::Mat4x2, float, glUniformMatrix4x2fv)
+QT3D_UNIFORM_TYPE_IMPL(UniformType::Mat3x4, float, glUniformMatrix3x4fv)
+QT3D_UNIFORM_TYPE_IMPL(UniformType::Mat4x3, float, glUniformMatrix4x3fv)
+
 } // namespace Render
 } // namespace Qt3DRender of namespace
 
diff --git a/src/render/graphicshelpers/graphicscontext_p.h b/src/render/graphicshelpers/graphicscontext_p.h
index d1b21a1d6..647db9e47 100644
--- a/src/render/graphicshelpers/graphicscontext_p.h
+++ b/src/render/graphicshelpers/graphicscontext_p.h
@@ -60,7 +60,7 @@
 #include <QMatrix4x4>
 #include <QBitArray>
 #include <QImage>
-#include <Qt3DRender/private/quniformvalue_p.h>
+#include <Qt3DRender/private/shaderparameterpack_p.h>
 #include <Qt3DRender/qclearbuffers.h>
 #include <Qt3DRender/private/shader_p.h>
 #include <Qt3DRender/private/glbuffer_p.h>
@@ -68,6 +68,7 @@
 #include <Qt3DRender/private/handle_types_p.h>
 #include <Qt3DRender/private/qgraphicsapifilter_p.h>
 #include <Qt3DRender/private/shadercache_p.h>
+#include <Qt3DRender/private/uniform_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -183,10 +184,10 @@ public:
 
     // Wrapper methods
     void    alphaTest(GLenum mode1, GLenum mode2);
+    void    bindFramebuffer(GLuint fbo);
     void    bindBufferBase(GLenum target, GLuint bindingIndex, GLuint buffer);
     void    bindFragOutputs(GLuint shader, const QHash<QString, int> &outputs);
     void    bindUniformBlock(GLuint programId, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
-    void    bindUniform(const QVariant &v, const ShaderUniform &description);
     void    bindShaderStorageBlock(GLuint programId, GLuint shaderStorageBlockIndex, GLuint shaderStorageBlockBinding);
     void    blendEquation(GLenum mode);
     void    blendFunci(GLuint buf, GLenum sfactor, GLenum dfactor);
@@ -314,8 +315,59 @@ private:
 
     void enableAttribute(const VAOVertexAttribute &attr);
     void disableAttribute(const VAOVertexAttribute &attr);
+
+    void applyUniform(const ShaderUniform &description, const UniformValue &v);
+
+    template<UniformType>
+    void applyUniformHelper(int, const UniformValue &) const
+    {
+        Q_ASSERT_X(false, Q_FUNC_INFO, "Uniform: Didn't provide specialized apply() implementation");
+    }
 };
 
+#define QT3D_UNIFORM_TYPE_PROTO(UniformTypeEnum, BaseType, Func) \
+template<> \
+void GraphicsContext::applyUniformHelper<UniformTypeEnum>(int location, const UniformValue &value) const;
+
+#define QT3D_UNIFORM_TYPE_IMPL(UniformTypeEnum, BaseType, Func) \
+    template<> \
+    void GraphicsContext::applyUniformHelper<UniformTypeEnum>(int location, const UniformValue &value) const \
+{ \
+    m_glHelper->Func(location, 1, value.constData<BaseType>()); \
+}
+
+
+QT3D_UNIFORM_TYPE_PROTO(UniformType::Float, float, glUniform1fv)
+QT3D_UNIFORM_TYPE_PROTO(UniformType::Vec2, float, glUniform2fv)
+QT3D_UNIFORM_TYPE_PROTO(UniformType::Vec3, float, glUniform3fv)
+QT3D_UNIFORM_TYPE_PROTO(UniformType::Vec4, float, glUniform4fv)
+
+// OpenGL expects int* as values for booleans
+QT3D_UNIFORM_TYPE_PROTO(UniformType::Bool, int, glUniform1iv)
+QT3D_UNIFORM_TYPE_PROTO(UniformType::BVec2, int, glUniform2iv)
+QT3D_UNIFORM_TYPE_PROTO(UniformType::BVec3, int, glUniform3iv)
+QT3D_UNIFORM_TYPE_PROTO(UniformType::BVec4, int, glUniform4iv)
+
+QT3D_UNIFORM_TYPE_PROTO(UniformType::Int, int, glUniform1iv)
+QT3D_UNIFORM_TYPE_PROTO(UniformType::IVec2, int, glUniform2iv)
+QT3D_UNIFORM_TYPE_PROTO(UniformType::IVec3, int, glUniform3iv)
+QT3D_UNIFORM_TYPE_PROTO(UniformType::IVec4, int, glUniform4iv)
+
+QT3D_UNIFORM_TYPE_PROTO(UniformType::UInt, uint, glUniform1uiv)
+QT3D_UNIFORM_TYPE_PROTO(UniformType::UIVec2, uint, glUniform2uiv)
+QT3D_UNIFORM_TYPE_PROTO(UniformType::UIVec3, uint, glUniform3uiv)
+QT3D_UNIFORM_TYPE_PROTO(UniformType::UIVec4, uint, glUniform4uiv)
+
+QT3D_UNIFORM_TYPE_PROTO(UniformType::Mat2, float, glUniformMatrix2fv)
+QT3D_UNIFORM_TYPE_PROTO(UniformType::Mat3, float, glUniformMatrix3fv)
+QT3D_UNIFORM_TYPE_PROTO(UniformType::Mat4, float, glUniformMatrix4fv)
+QT3D_UNIFORM_TYPE_PROTO(UniformType::Mat2x3, float, glUniformMatrix2x3fv)
+QT3D_UNIFORM_TYPE_PROTO(UniformType::Mat3x2, float, glUniformMatrix3x2fv)
+QT3D_UNIFORM_TYPE_PROTO(UniformType::Mat2x4, float, glUniformMatrix2x4fv)
+QT3D_UNIFORM_TYPE_PROTO(UniformType::Mat4x2, float, glUniformMatrix4x2fv)
+QT3D_UNIFORM_TYPE_PROTO(UniformType::Mat3x4, float, glUniformMatrix3x4fv)
+QT3D_UNIFORM_TYPE_PROTO(UniformType::Mat4x3, float, glUniformMatrix4x3fv)
+
 } // namespace Render
 } // namespace Qt3DRender
 
diff --git a/src/render/graphicshelpers/graphicshelperes2.cpp b/src/render/graphicshelpers/graphicshelperes2.cpp
index bf26fcc63..3a268cb5f 100644
--- a/src/render/graphicshelpers/graphicshelperes2.cpp
+++ b/src/render/graphicshelpers/graphicshelperes2.cpp
@@ -359,108 +359,6 @@ void GraphicsHelperES2::drawBuffers(GLsizei, const int *)
     qWarning() << "drawBuffers is not supported by ES 2.0";
 }
 
-void GraphicsHelperES2::bindUniform(const QVariant &v, const ShaderUniform &description)
-{
-    switch (description.m_type) {
-
-    case GL_FLOAT:
-        m_funcs->glUniform1fv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 1));
-        break;
-
-    case GL_FLOAT_VEC2:
-        m_funcs->glUniform2fv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 2));
-        break;
-
-    case GL_FLOAT_VEC3:
-        m_funcs->glUniform3fv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 3));
-        break;
-
-    case GL_FLOAT_VEC4:
-        m_funcs->glUniform4fv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 4));
-        break;
-
-    case GL_FLOAT_MAT2:
-        m_funcs->glUniformMatrix2fv(description.m_location, description.m_size, GL_FALSE,
-                                    QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 4));
-        break;
-
-    case GL_FLOAT_MAT3:
-        m_funcs->glUniformMatrix3fv(description.m_location, description.m_size, GL_FALSE,
-                                    QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 9));
-        break;
-
-    case GL_FLOAT_MAT4:
-        m_funcs->glUniformMatrix4fv(description.m_location, description.m_size, GL_FALSE,
-                                    QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 16));
-        break;
-
-    case GL_INT:
-        m_funcs->glUniform1iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 1));
-        break;
-
-    case GL_INT_VEC2:
-        m_funcs->glUniform2iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 2));
-        break;
-
-    case GL_INT_VEC3:
-        m_funcs->glUniform3iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 3));
-        break;
-
-    case GL_INT_VEC4:
-        m_funcs->glUniform4iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 4));
-        break;
-
-    case GL_BOOL:
-        m_funcs->glUniform1iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 1));
-        break;
-
-    case GL_BOOL_VEC2:
-        m_funcs->glUniform2iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 2));
-        break;
-
-    case GL_BOOL_VEC3:
-        m_funcs->glUniform3iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 3));
-        break;
-
-    case GL_BOOL_VEC4:
-        m_funcs->glUniform4iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 4));
-        break;
-
-    case GL_SAMPLER_2D:
-    case GL_SAMPLER_CUBE: {
-        Q_ASSERT(description.m_size == 1);
-        m_funcs->glUniform1i(description.m_location, v.toInt());
-        break;
-    }
-
-        // ES 3.0+
-    case GL_SAMPLER_3D:
-    case GL_SAMPLER_2D_SHADOW:
-    case GL_SAMPLER_CUBE_SHADOW:
-    case GL_SAMPLER_2D_ARRAY:
-    case GL_SAMPLER_2D_ARRAY_SHADOW:
-        qWarning() << Q_FUNC_INFO << "ES 3.0 uniform type" << description.m_type << "for"
-                   << description.m_name << "is not supported in ES 2.0";
-        break;
-
-    default:
-        qWarning() << Q_FUNC_INFO << "unsupported uniform type:" << description.m_type << "for " << description.m_name;
-        break;
-    }
-}
-
 void GraphicsHelperES2::bindFragDataLocation(GLuint , const QHash<QString, int> &)
 {
     qCritical() << "bindFragDataLocation is not supported by ES 2.0";
@@ -760,6 +658,49 @@ void GraphicsHelperES2::glUniformMatrix4x3fv(GLint , GLsizei , const GLfloat *)
     qWarning() << "glUniformMatrix4x3fv not supported by ES 2";
 }
 
+UniformType GraphicsHelperES2::uniformTypeFromGLType(GLenum type)
+{
+    switch (type) {
+    case GL_FLOAT:
+        return UniformType::Float;
+    case GL_FLOAT_VEC2:
+        return UniformType::Vec2;
+    case GL_FLOAT_VEC3:
+        return UniformType::Vec3;
+    case GL_FLOAT_VEC4:
+        return UniformType::Vec4;
+    case GL_FLOAT_MAT2:
+        return UniformType::Mat2;
+    case GL_FLOAT_MAT3:
+        return UniformType::Mat3;
+    case GL_FLOAT_MAT4:
+        return UniformType::Mat4;
+    case GL_INT:
+        return UniformType::Int;
+    case GL_INT_VEC2:
+        return UniformType::IVec2;
+    case GL_INT_VEC3:
+        return UniformType::IVec3;
+    case GL_INT_VEC4:
+        return UniformType::IVec4;
+    case GL_BOOL:
+        return UniformType::Bool;
+    case GL_BOOL_VEC2:
+        return UniformType::BVec2;
+    case GL_BOOL_VEC3:
+        return UniformType::BVec3;
+    case GL_BOOL_VEC4:
+        return UniformType::BVec4;
+
+    case GL_SAMPLER_2D:
+    case GL_SAMPLER_CUBE:
+        return UniformType::Sampler;
+    default:
+        Q_UNREACHABLE();
+        return UniformType::Float;
+    }
+}
+
 } // namespace Render
 } // namespace Qt3DRender
 
diff --git a/src/render/graphicshelpers/graphicshelperes2_p.h b/src/render/graphicshelpers/graphicshelperes2_p.h
index 0fd510a4d..52d68f691 100644
--- a/src/render/graphicshelpers/graphicshelperes2_p.h
+++ b/src/render/graphicshelpers/graphicshelperes2_p.h
@@ -74,7 +74,6 @@ public:
     void bindFrameBufferObject(GLuint frameBufferId) Q_DECL_OVERRIDE;
     void bindShaderStorageBlock(GLuint programId, GLuint shaderStorageBlockIndex, GLuint shaderStorageBlockBinding) Q_DECL_OVERRIDE;
     void bindUniformBlock(GLuint programId, GLuint uniformBlockIndex, GLuint uniformBlockBinding) Q_DECL_OVERRIDE;
-    void bindUniform(const QVariant &v, const ShaderUniform &description) Q_DECL_OVERRIDE;
     void blendEquation(GLenum mode) Q_DECL_OVERRIDE;
     void blendFunci(GLuint buf, GLenum sfactor, GLenum dfactor) Q_DECL_OVERRIDE;
     void blendFuncSeparatei(GLuint buf, GLenum sRGB, GLenum dRGB, GLenum sAlpha, GLenum dAlpha) Q_DECL_OVERRIDE;
@@ -144,6 +143,8 @@ public:
     void glUniformMatrix3x4fv(GLint location, GLsizei count, const GLfloat *value) Q_DECL_OVERRIDE;
     void glUniformMatrix4x3fv(GLint location, GLsizei count, const GLfloat *value) Q_DECL_OVERRIDE;
 
+    UniformType uniformTypeFromGLType(GLenum glType) Q_DECL_OVERRIDE;
+
 protected:
     QOpenGLFunctions *m_funcs;
 };
diff --git a/src/render/graphicshelpers/graphicshelperes3.cpp b/src/render/graphicshelpers/graphicshelperes3.cpp
index fe39d9d3f..eb492e98d 100644
--- a/src/render/graphicshelpers/graphicshelperes3.cpp
+++ b/src/render/graphicshelpers/graphicshelperes3.cpp
@@ -150,20 +150,17 @@ void GraphicsHelperES3::drawBuffers(GLsizei n, const int *bufs)
     m_extraFuncs->glDrawBuffers(n, drawBufs.constData());
 }
 
-void GraphicsHelperES3::bindUniform(const QVariant &v, const ShaderUniform &description)
+UniformType GraphicsHelperES3::uniformTypeFromGLType(GLenum glType)
 {
-    switch (description.m_type) {
+    switch (glType) {
     case GL_SAMPLER_3D:
     case GL_SAMPLER_2D_SHADOW:
     case GL_SAMPLER_CUBE_SHADOW:
     case GL_SAMPLER_2D_ARRAY:
     case GL_SAMPLER_2D_ARRAY_SHADOW:
-        Q_ASSERT(description.m_size == 1);
-        m_funcs->glUniform1i(description.m_location, v.toInt());
-        break;
+        return UniformType::Sampler;
     default:
-        GraphicsHelperES2::bindUniform(v, description);
-        break;
+       return GraphicsHelperES2::uniformTypeFromGLType(glType);
     }
 }
 
diff --git a/src/render/graphicshelpers/graphicshelperes3_p.h b/src/render/graphicshelpers/graphicshelperes3_p.h
index e5bb51c53..2844c140d 100644
--- a/src/render/graphicshelpers/graphicshelperes3_p.h
+++ b/src/render/graphicshelpers/graphicshelperes3_p.h
@@ -67,12 +67,14 @@ public:
 
     // QGraphicHelperInterface interface
     virtual void bindFrameBufferAttachment(QOpenGLTexture *texture, const Attachment &attachment) Q_DECL_OVERRIDE;
-    virtual void bindUniform(const QVariant &v, const ShaderUniform &description) Q_DECL_OVERRIDE;
     virtual void drawBuffers(GLsizei n, const int *bufs) Q_DECL_OVERRIDE;
     virtual void drawElementsInstancedBaseVertexBaseInstance(GLenum primitiveType, GLsizei primitiveCount, GLint indexType, void *indices, GLsizei instances, GLint baseVertex = 0,  GLint baseInstance = 0) Q_DECL_OVERRIDE;
     virtual void initializeHelper(QOpenGLContext *context, QAbstractOpenGLFunctions *functions) Q_DECL_OVERRIDE;
     virtual bool supportsFeature(Feature feature) const Q_DECL_OVERRIDE;
     virtual void vertexAttribDivisor(GLuint index, GLuint divisor) Q_DECL_OVERRIDE;
+
+    UniformType uniformTypeFromGLType(GLenum glType) Q_DECL_OVERRIDE;
+
 protected:
     QOpenGLExtraFunctions *m_extraFuncs = Q_NULLPTR;
 };
diff --git a/src/render/graphicshelpers/graphicshelpergl2.cpp b/src/render/graphicshelpers/graphicshelpergl2.cpp
index 6ab69b491..1315b4ab8 100644
--- a/src/render/graphicshelpers/graphicshelpergl2.cpp
+++ b/src/render/graphicshelpers/graphicshelpergl2.cpp
@@ -58,7 +58,7 @@ GraphicsHelperGL2::GraphicsHelperGL2()
 }
 
 void GraphicsHelperGL2::initializeHelper(QOpenGLContext *context,
-                                          QAbstractOpenGLFunctions *functions)
+                                         QAbstractOpenGLFunctions *functions)
 {
     Q_UNUSED(context);
     m_funcs = static_cast<QOpenGLFunctions_2_0*>(functions);
@@ -95,9 +95,9 @@ void GraphicsHelperGL2::drawElementsInstancedBaseVertexBaseInstance(GLenum primi
 }
 
 void GraphicsHelperGL2::drawArraysInstanced(GLenum primitiveType,
-                                             GLint first,
-                                             GLsizei count,
-                                             GLsizei instances)
+                                            GLint first,
+                                            GLsizei count,
+                                            GLsizei instances)
 {
     for (GLint i = 0; i < instances; i++)
         drawArrays(primitiveType,
@@ -116,10 +116,10 @@ void GraphicsHelperGL2::drawArraysInstancedBaseInstance(GLenum primitiveType, GL
 }
 
 void GraphicsHelperGL2::drawElements(GLenum primitiveType,
-                                      GLsizei primitiveCount,
-                                      GLint indexType,
-                                      void *indices,
-                                      GLint baseVertex)
+                                     GLsizei primitiveCount,
+                                     GLint indexType,
+                                     void *indices,
+                                     GLint baseVertex)
 {
     if (baseVertex != 0)
         qWarning() << "glDrawElementsBaseVertex is not supported with OpenGL 2";
@@ -131,8 +131,8 @@ void GraphicsHelperGL2::drawElements(GLenum primitiveType,
 }
 
 void GraphicsHelperGL2::drawArrays(GLenum primitiveType,
-                                    GLint first,
-                                    GLsizei count)
+                                   GLint first,
+                                   GLsizei count)
 {
     m_funcs->glDrawArrays(primitiveType,
                           first,
@@ -211,7 +211,7 @@ QVector<ShaderStorageBlock> GraphicsHelperGL2::programShaderStorageBlocks(GLuint
 }
 
 void GraphicsHelperGL2::vertexAttribDivisor(GLuint index,
-                                             GLuint divisor)
+                                            GLuint divisor)
 {
     Q_UNUSED(index);
     Q_UNUSED(divisor);
@@ -358,98 +358,6 @@ void GraphicsHelperGL2::bindFragDataLocation(GLuint, const QHash<QString, int> &
     qCritical() << "bindFragDataLocation is not supported by GL 2.0";
 }
 
-void GraphicsHelperGL2::bindUniform(const QVariant &v, const ShaderUniform &description)
-{
-    switch (description.m_type) {
-
-    case GL_FLOAT:
-        m_funcs->glUniform1fv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 1));
-        break;
-
-    case GL_FLOAT_VEC2:
-        m_funcs->glUniform2fv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 2));
-        break;
-
-    case GL_FLOAT_VEC3:
-        m_funcs->glUniform3fv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 3));
-        break;
-
-    case GL_FLOAT_VEC4:
-        m_funcs->glUniform4fv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 4));
-        break;
-
-    case GL_FLOAT_MAT2:
-        m_funcs->glUniformMatrix2fv(description.m_location, description.m_size, GL_FALSE,
-                                    QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 4));
-        break;
-
-    case GL_FLOAT_MAT3:
-        m_funcs->glUniformMatrix3fv(description.m_location, description.m_size, GL_FALSE,
-                                    QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 9));
-        break;
-
-    case GL_FLOAT_MAT4:
-        m_funcs->glUniformMatrix4fv(description.m_location, description.m_size, GL_FALSE,
-                                    QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 16));
-        break;
-
-    case GL_INT:
-        m_funcs->glUniform1iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 1));
-        break;
-
-    case GL_INT_VEC2:
-        m_funcs->glUniform2iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 2));
-        break;
-
-    case GL_INT_VEC3:
-        m_funcs->glUniform3iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 3));
-        break;
-
-    case GL_INT_VEC4:
-        m_funcs->glUniform4iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 4));
-        break;
-
-    case GL_BOOL:
-        m_funcs->glUniform1iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 1));
-        break;
-
-    case GL_BOOL_VEC2:
-        m_funcs->glUniform2iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 2));
-        break;
-
-    case GL_BOOL_VEC3:
-        m_funcs->glUniform3iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 3));
-        break;
-
-    case GL_BOOL_VEC4:
-        m_funcs->glUniform4iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 4));
-        break;
-
-    case GL_SAMPLER_2D:
-    case GL_SAMPLER_CUBE: {
-        Q_ASSERT(description.m_size == 1);
-        m_funcs->glUniform1i(description.m_location, v.toInt());
-        break;
-    }
-
-    default:
-        qWarning() << Q_FUNC_INFO << "unsupported uniform type:" << description.m_type << "for " << description.m_name;
-        break;
-    }
-}
-
 void GraphicsHelperGL2::bindFrameBufferObject(GLuint frameBufferId)
 {
     if (m_fboFuncs != nullptr)
@@ -775,6 +683,54 @@ void GraphicsHelperGL2::glUniformMatrix4x3fv(GLint , GLsizei , const GLfloat *)
     qWarning() << "glUniformMatrix4x3fv not supported by GL 2";
 }
 
+UniformType GraphicsHelperGL2::uniformTypeFromGLType(GLenum type)
+{
+    switch (type) {
+    case GL_FLOAT:
+        return UniformType::Float;
+    case GL_FLOAT_VEC2:
+        return UniformType::Vec2;
+    case GL_FLOAT_VEC3:
+        return UniformType::Vec3;
+    case GL_FLOAT_VEC4:
+        return UniformType::Vec4;
+    case GL_FLOAT_MAT2:
+        return UniformType::Mat2;
+    case GL_FLOAT_MAT3:
+        return UniformType::Mat3;
+    case GL_FLOAT_MAT4:
+        return UniformType::Mat4;
+    case GL_INT:
+        return UniformType::Int;
+    case GL_INT_VEC2:
+        return UniformType::IVec2;
+    case GL_INT_VEC3:
+        return UniformType::IVec3;
+    case GL_INT_VEC4:
+        return UniformType::IVec4;
+    case GL_BOOL:
+        return UniformType::Bool;
+    case GL_BOOL_VEC2:
+        return UniformType::BVec2;
+    case GL_BOOL_VEC3:
+        return UniformType::BVec3;
+    case GL_BOOL_VEC4:
+        return UniformType::BVec4;
+
+    case GL_SAMPLER_1D:
+    case GL_SAMPLER_1D_SHADOW:
+    case GL_SAMPLER_2D:
+    case GL_SAMPLER_2D_SHADOW:
+    case GL_SAMPLER_CUBE:
+    case GL_SAMPLER_3D:
+        return UniformType::Sampler;
+
+    default:
+        Q_UNREACHABLE();
+        return UniformType::Float;
+    }
+}
+
 } // namespace Render
 } // namespace Qt3DRender
 
diff --git a/src/render/graphicshelpers/graphicshelpergl2_p.h b/src/render/graphicshelpers/graphicshelpergl2_p.h
index 3b9c1e881..0352c77d3 100644
--- a/src/render/graphicshelpers/graphicshelpergl2_p.h
+++ b/src/render/graphicshelpers/graphicshelpergl2_p.h
@@ -76,7 +76,6 @@ public:
     void bindFrameBufferObject(GLuint frameBufferId) Q_DECL_OVERRIDE;
     void bindShaderStorageBlock(GLuint programId, GLuint shaderStorageBlockIndex, GLuint shaderStorageBlockBinding) Q_DECL_OVERRIDE;
     void bindUniformBlock(GLuint programId, GLuint uniformBlockIndex, GLuint uniformBlockBinding) Q_DECL_OVERRIDE;
-    void bindUniform(const QVariant &v, const ShaderUniform &description) Q_DECL_OVERRIDE;
     void blendEquation(GLenum mode) Q_DECL_OVERRIDE;
     void blendFunci(GLuint buf, GLenum sfactor, GLenum dfactor) Q_DECL_OVERRIDE;
     void blendFuncSeparatei(GLuint buf, GLenum sRGB, GLenum dRGB, GLenum sAlpha, GLenum dAlpha) Q_DECL_OVERRIDE;
@@ -146,6 +145,8 @@ public:
     void glUniformMatrix3x4fv(GLint location, GLsizei count, const GLfloat *value) Q_DECL_OVERRIDE;
     void glUniformMatrix4x3fv(GLint location, GLsizei count, const GLfloat *value) Q_DECL_OVERRIDE;
 
+    UniformType uniformTypeFromGLType(GLenum glType) Q_DECL_OVERRIDE;
+
 private:
     QOpenGLFunctions_2_0 *m_funcs;
     QOpenGLExtension_ARB_framebuffer_object *m_fboFuncs;
diff --git a/src/render/graphicshelpers/graphicshelpergl3.cpp b/src/render/graphicshelpers/graphicshelpergl3.cpp
index 52028b1c9..da1b95db8 100644
--- a/src/render/graphicshelpers/graphicshelpergl3.cpp
+++ b/src/render/graphicshelpers/graphicshelpergl3.cpp
@@ -410,182 +410,6 @@ void GraphicsHelperGL3::bindFragDataLocation(GLuint shader, const QHash<QString,
         m_funcs->glBindFragDataLocation(shader, it.value(), it.key().toStdString().c_str());
 }
 
-void GraphicsHelperGL3::bindUniform(const QVariant &v, const ShaderUniform &description)
-{
-    switch (description.m_type) {
-
-    case GL_FLOAT:
-        m_funcs->glUniform1fv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 1));
-        break;
-
-    case GL_FLOAT_VEC2:
-        m_funcs->glUniform2fv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 2));
-        break;
-
-    case GL_FLOAT_VEC3:
-        m_funcs->glUniform3fv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 3));
-        break;
-
-    case GL_FLOAT_VEC4:
-        m_funcs->glUniform4fv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 4));
-        break;
-
-    case GL_FLOAT_MAT2:
-        m_funcs->glUniformMatrix2fv(description.m_location, description.m_size, GL_FALSE,
-                                    QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 4));
-        break;
-
-    case GL_FLOAT_MAT2x3:
-        m_funcs->glUniformMatrix2x3fv(description.m_location, description.m_size, GL_FALSE,
-                                      QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 6));
-        break;
-
-    case GL_FLOAT_MAT2x4:
-        m_funcs->glUniformMatrix2x4fv(description.m_location, description.m_size, GL_FALSE,
-                                      QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 8));
-        break;
-
-    case GL_FLOAT_MAT3:
-        m_funcs->glUniformMatrix3fv(description.m_location, description.m_size, GL_FALSE,
-                                    QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 9));
-        break;
-
-    case GL_FLOAT_MAT3x2:
-        m_funcs->glUniformMatrix3x2fv(description.m_location, description.m_size,  GL_FALSE,
-                                      QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 6));
-        break;
-
-    case GL_FLOAT_MAT3x4:
-        m_funcs->glUniformMatrix3x4fv(description.m_location, description.m_size, GL_FALSE,
-                                      QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 12));
-        break;
-
-    case GL_FLOAT_MAT4:
-        m_funcs->glUniformMatrix4fv(description.m_location, description.m_size, GL_FALSE,
-                                    QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 16));
-        break;
-
-    case GL_FLOAT_MAT4x2:
-        m_funcs->glUniformMatrix4x2fv(description.m_location, description.m_size, GL_FALSE,
-                                      QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 8));
-        break;
-
-    case GL_FLOAT_MAT4x3:
-        m_funcs->glUniformMatrix4x3fv(description.m_location, description.m_size, GL_FALSE,
-                                      QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 12));
-        break;
-
-    case GL_INT:
-        m_funcs->glUniform1iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 1));
-        break;
-
-    case GL_INT_VEC2:
-        m_funcs->glUniform2iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 2));
-        break;
-
-    case GL_INT_VEC3:
-        m_funcs->glUniform3iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 3));
-        break;
-
-    case GL_INT_VEC4:
-        m_funcs->glUniform4iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 4));
-        break;
-
-    case GL_UNSIGNED_INT:
-        m_funcs->glUniform1uiv(description.m_location, description.m_size,
-                               QGraphicsUtils::valueArrayFromVariant<GLuint>(v, description.m_size, 1));
-        break;
-
-    case GL_UNSIGNED_INT_VEC2:
-        m_funcs->glUniform2uiv(description.m_location, description.m_size,
-                               QGraphicsUtils::valueArrayFromVariant<GLuint>(v, description.m_size, 2));
-        break;
-
-    case GL_UNSIGNED_INT_VEC3:
-        m_funcs->glUniform3uiv(description.m_location, description.m_size,
-                               QGraphicsUtils::valueArrayFromVariant<GLuint>(v, description.m_size, 3));
-        break;
-
-    case GL_UNSIGNED_INT_VEC4:
-        m_funcs->glUniform4uiv(description.m_location, description.m_size,
-                               QGraphicsUtils::valueArrayFromVariant<GLuint>(v, description.m_size, 4));
-        break;
-
-    case GL_BOOL:
-        m_funcs->glUniform1iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 1));
-        break;
-
-    case GL_BOOL_VEC2:
-        m_funcs->glUniform2iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 2));
-        break;
-
-    case GL_BOOL_VEC3:
-        m_funcs->glUniform3iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 3));
-        break;
-
-    case GL_BOOL_VEC4:
-        m_funcs->glUniform4iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 4));
-        break;
-
-    case GL_SAMPLER_1D:
-    case GL_SAMPLER_2D:
-    case GL_SAMPLER_3D:
-    case GL_SAMPLER_CUBE:
-    case GL_SAMPLER_BUFFER:
-    case GL_SAMPLER_2D_RECT:
-    case GL_INT_SAMPLER_1D:
-    case GL_INT_SAMPLER_2D:
-    case GL_INT_SAMPLER_3D:
-    case GL_INT_SAMPLER_CUBE:
-    case GL_INT_SAMPLER_BUFFER:
-    case GL_INT_SAMPLER_2D_RECT:
-    case GL_UNSIGNED_INT_SAMPLER_1D:
-    case GL_UNSIGNED_INT_SAMPLER_2D:
-    case GL_UNSIGNED_INT_SAMPLER_3D:
-    case GL_UNSIGNED_INT_SAMPLER_CUBE:
-    case GL_UNSIGNED_INT_SAMPLER_BUFFER:
-    case GL_UNSIGNED_INT_SAMPLER_2D_RECT:
-    case GL_SAMPLER_1D_SHADOW:
-    case GL_SAMPLER_2D_SHADOW:
-    case GL_SAMPLER_CUBE_SHADOW:
-    case GL_SAMPLER_1D_ARRAY:
-    case GL_SAMPLER_2D_ARRAY:
-    case GL_INT_SAMPLER_1D_ARRAY:
-    case GL_INT_SAMPLER_2D_ARRAY:
-    case GL_UNSIGNED_INT_SAMPLER_1D_ARRAY:
-    case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
-    case GL_SAMPLER_1D_ARRAY_SHADOW:
-    case GL_SAMPLER_2D_ARRAY_SHADOW:
-    case GL_SAMPLER_2D_RECT_SHADOW:
-    case GL_SAMPLER_2D_MULTISAMPLE:
-    case GL_INT_SAMPLER_2D_MULTISAMPLE:
-    case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:
-    case GL_SAMPLER_2D_MULTISAMPLE_ARRAY:
-    case GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
-    case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY: {
-        Q_ASSERT(description.m_size == 1);
-        m_funcs->glUniform1i(description.m_location, v.toInt());
-        break;
-    }
-
-    default:
-        qWarning() << Q_FUNC_INFO << "unsupported uniform type:" << description.m_type << "for " << description.m_name;
-        break;
-    }
-}
-
 void GraphicsHelperGL3::bindUniformBlock(GLuint programId, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
 {
     m_funcs->glUniformBlockBinding(programId, uniformBlockIndex, uniformBlockBinding);
@@ -1139,6 +963,88 @@ void GraphicsHelperGL3::glUniformMatrix4x3fv(GLint location, GLsizei count, cons
     m_funcs->glUniformMatrix4x3fv(location, count, false, values);
 }
 
+UniformType GraphicsHelperGL3::uniformTypeFromGLType(GLenum type)
+{
+    switch (type) {
+    case GL_FLOAT:
+        return UniformType::Float;
+    case GL_FLOAT_VEC2:
+        return UniformType::Vec2;
+    case GL_FLOAT_VEC3:
+        return UniformType::Vec3;
+    case GL_FLOAT_VEC4:
+        return UniformType::Vec4;
+    case GL_FLOAT_MAT2:
+        return UniformType::Mat2;
+    case GL_FLOAT_MAT3:
+        return UniformType::Mat3;
+    case GL_FLOAT_MAT4:
+        return UniformType::Mat4;
+    case GL_FLOAT_MAT2x3:
+        return UniformType::Mat2x3;
+    case GL_FLOAT_MAT3x2:
+        return UniformType::Mat3x2;
+    case GL_FLOAT_MAT2x4:
+        return UniformType::Mat2x4;
+    case GL_FLOAT_MAT4x2:
+        return UniformType::Mat4x2;
+    case GL_FLOAT_MAT3x4:
+        return UniformType::Mat3x4;
+    case GL_FLOAT_MAT4x3:
+        return UniformType::Mat4x3;
+    case GL_INT:
+        return UniformType::Int;
+    case GL_INT_VEC2:
+        return UniformType::IVec2;
+    case GL_INT_VEC3:
+        return UniformType::IVec3;
+    case GL_INT_VEC4:
+        return UniformType::IVec4;
+    case GL_BOOL:
+        return UniformType::Bool;
+    case GL_BOOL_VEC2:
+        return UniformType::BVec2;
+    case GL_BOOL_VEC3:
+        return UniformType::BVec3;
+    case GL_BOOL_VEC4:
+        return UniformType::BVec4;
+
+    case GL_SAMPLER_1D:
+    case GL_SAMPLER_1D_SHADOW:
+    case GL_SAMPLER_2D:
+    case GL_SAMPLER_2D_RECT:
+    case GL_SAMPLER_2D_SHADOW:
+    case GL_SAMPLER_2D_RECT_SHADOW:
+    case GL_SAMPLER_CUBE:
+    case GL_SAMPLER_CUBE_SHADOW:
+    case GL_SAMPLER_2D_ARRAY:
+    case GL_SAMPLER_2D_ARRAY_SHADOW:
+    case GL_SAMPLER_2D_MULTISAMPLE:
+    case GL_SAMPLER_2D_MULTISAMPLE_ARRAY:
+    case GL_SAMPLER_3D:
+    case GL_INT_SAMPLER_1D:
+    case GL_INT_SAMPLER_2D:
+    case GL_INT_SAMPLER_3D:
+    case GL_INT_SAMPLER_CUBE:
+    case GL_INT_SAMPLER_1D_ARRAY:
+    case GL_INT_SAMPLER_2D_ARRAY:
+    case GL_INT_SAMPLER_2D_MULTISAMPLE:
+    case GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
+    case GL_UNSIGNED_INT_SAMPLER_1D:
+    case GL_UNSIGNED_INT_SAMPLER_2D:
+    case GL_UNSIGNED_INT_SAMPLER_3D:
+    case GL_UNSIGNED_INT_SAMPLER_CUBE:
+    case GL_UNSIGNED_INT_SAMPLER_1D_ARRAY:
+    case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
+    case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:
+    case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
+        return UniformType::Sampler;
+    default:
+        Q_UNREACHABLE();
+        return UniformType::Float;
+    }
+}
+
 } // namespace Render
 } // namespace Qt3DRender
 
diff --git a/src/render/graphicshelpers/graphicshelpergl3_3.cpp b/src/render/graphicshelpers/graphicshelpergl3_3.cpp
index e701887a9..53b89bdef 100644
--- a/src/render/graphicshelpers/graphicshelpergl3_3.cpp
+++ b/src/render/graphicshelpers/graphicshelpergl3_3.cpp
@@ -76,6 +76,10 @@ GraphicsHelperGL3_3::GraphicsHelperGL3_3()
 {
 }
 
+GraphicsHelperGL3_3::~GraphicsHelperGL3_3()
+{
+}
+
 void GraphicsHelperGL3_3::initializeHelper(QOpenGLContext *context,
                                             QAbstractOpenGLFunctions *functions)
 {
@@ -383,6 +387,7 @@ bool GraphicsHelperGL3_3::supportsFeature(GraphicsHelperInterface::Feature featu
     case PrimitiveRestart:
     case RenderBufferDimensionRetrieval:
     case TextureDimensionRetrieval:
+    case BindableFragmentOutputs:
         return true;
     case Tessellation:
         return !m_tessFuncs.isNull();
@@ -407,182 +412,6 @@ void GraphicsHelperGL3_3::bindFragDataLocation(GLuint shader, const QHash<QStrin
         m_funcs->glBindFragDataLocation(shader, it.value(), it.key().toStdString().c_str());
 }
 
-void GraphicsHelperGL3_3::bindUniform(const QVariant &v, const ShaderUniform &description)
-{
-    switch (description.m_type) {
-
-    case GL_FLOAT:
-        m_funcs->glUniform1fv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 1));
-        break;
-
-    case GL_FLOAT_VEC2:
-        m_funcs->glUniform2fv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 2));
-        break;
-
-    case GL_FLOAT_VEC3:
-        m_funcs->glUniform3fv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 3));
-        break;
-
-    case GL_FLOAT_VEC4:
-        m_funcs->glUniform4fv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 4));
-        break;
-
-    case GL_FLOAT_MAT2:
-        m_funcs->glUniformMatrix2fv(description.m_location, description.m_size, GL_FALSE,
-                                    QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 4));
-        break;
-
-    case GL_FLOAT_MAT2x3:
-        m_funcs->glUniformMatrix2x3fv(description.m_location, description.m_size, GL_FALSE,
-                                      QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 6));
-        break;
-
-    case GL_FLOAT_MAT2x4:
-        m_funcs->glUniformMatrix2x4fv(description.m_location, description.m_size, GL_FALSE,
-                                      QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 8));
-        break;
-
-    case GL_FLOAT_MAT3:
-        m_funcs->glUniformMatrix3fv(description.m_location, description.m_size, GL_FALSE,
-                                    QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 9));
-        break;
-
-    case GL_FLOAT_MAT3x2:
-        m_funcs->glUniformMatrix3x2fv(description.m_location, description.m_size,  GL_FALSE,
-                                      QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 6));
-        break;
-
-    case GL_FLOAT_MAT3x4:
-        m_funcs->glUniformMatrix3x4fv(description.m_location, description.m_size, GL_FALSE,
-                                      QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 12));
-        break;
-
-    case GL_FLOAT_MAT4:
-        m_funcs->glUniformMatrix4fv(description.m_location, description.m_size, GL_FALSE,
-                                    QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 16));
-        break;
-
-    case GL_FLOAT_MAT4x2:
-        m_funcs->glUniformMatrix4x2fv(description.m_location, description.m_size, GL_FALSE,
-                                      QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 8));
-        break;
-
-    case GL_FLOAT_MAT4x3:
-        m_funcs->glUniformMatrix4x3fv(description.m_location, description.m_size, GL_FALSE,
-                                      QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 12));
-        break;
-
-    case GL_INT:
-        m_funcs->glUniform1iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 1));
-        break;
-
-    case GL_INT_VEC2:
-        m_funcs->glUniform2iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 2));
-        break;
-
-    case GL_INT_VEC3:
-        m_funcs->glUniform3iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 3));
-        break;
-
-    case GL_INT_VEC4:
-        m_funcs->glUniform4iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 4));
-        break;
-
-    case GL_UNSIGNED_INT:
-        m_funcs->glUniform1uiv(description.m_location, description.m_size,
-                               QGraphicsUtils::valueArrayFromVariant<GLuint>(v, description.m_size, 1));
-        break;
-
-    case GL_UNSIGNED_INT_VEC2:
-        m_funcs->glUniform2uiv(description.m_location, description.m_size,
-                               QGraphicsUtils::valueArrayFromVariant<GLuint>(v, description.m_size, 2));
-        break;
-
-    case GL_UNSIGNED_INT_VEC3:
-        m_funcs->glUniform3uiv(description.m_location, description.m_size,
-                               QGraphicsUtils::valueArrayFromVariant<GLuint>(v, description.m_size, 3));
-        break;
-
-    case GL_UNSIGNED_INT_VEC4:
-        m_funcs->glUniform4uiv(description.m_location, description.m_size,
-                               QGraphicsUtils::valueArrayFromVariant<GLuint>(v, description.m_size, 4));
-        break;
-
-    case GL_BOOL:
-        m_funcs->glUniform1iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 1));
-        break;
-
-    case GL_BOOL_VEC2:
-        m_funcs->glUniform2iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 2));
-        break;
-
-    case GL_BOOL_VEC3:
-        m_funcs->glUniform3iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 3));
-        break;
-
-    case GL_BOOL_VEC4:
-        m_funcs->glUniform4iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 4));
-        break;
-
-    case GL_SAMPLER_1D:
-    case GL_SAMPLER_2D:
-    case GL_SAMPLER_3D:
-    case GL_SAMPLER_CUBE:
-    case GL_SAMPLER_BUFFER:
-    case GL_SAMPLER_2D_RECT:
-    case GL_INT_SAMPLER_1D:
-    case GL_INT_SAMPLER_2D:
-    case GL_INT_SAMPLER_3D:
-    case GL_INT_SAMPLER_CUBE:
-    case GL_INT_SAMPLER_BUFFER:
-    case GL_INT_SAMPLER_2D_RECT:
-    case GL_UNSIGNED_INT_SAMPLER_1D:
-    case GL_UNSIGNED_INT_SAMPLER_2D:
-    case GL_UNSIGNED_INT_SAMPLER_3D:
-    case GL_UNSIGNED_INT_SAMPLER_CUBE:
-    case GL_UNSIGNED_INT_SAMPLER_BUFFER:
-    case GL_UNSIGNED_INT_SAMPLER_2D_RECT:
-    case GL_SAMPLER_1D_SHADOW:
-    case GL_SAMPLER_2D_SHADOW:
-    case GL_SAMPLER_CUBE_SHADOW:
-    case GL_SAMPLER_1D_ARRAY:
-    case GL_SAMPLER_2D_ARRAY:
-    case GL_INT_SAMPLER_1D_ARRAY:
-    case GL_INT_SAMPLER_2D_ARRAY:
-    case GL_UNSIGNED_INT_SAMPLER_1D_ARRAY:
-    case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
-    case GL_SAMPLER_1D_ARRAY_SHADOW:
-    case GL_SAMPLER_2D_ARRAY_SHADOW:
-    case GL_SAMPLER_2D_RECT_SHADOW:
-    case GL_SAMPLER_2D_MULTISAMPLE:
-    case GL_INT_SAMPLER_2D_MULTISAMPLE:
-    case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:
-    case GL_SAMPLER_2D_MULTISAMPLE_ARRAY:
-    case GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
-    case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY: {
-        Q_ASSERT(description.m_size == 1);
-        m_funcs->glUniform1i(description.m_location, v.toInt());
-        break;
-    }
-
-    default:
-        qWarning() << Q_FUNC_INFO << "unsupported uniform type:" << description.m_type << "for " << description.m_name;
-        break;
-    }
-}
-
 void GraphicsHelperGL3_3::bindUniformBlock(GLuint programId, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
 {
     m_funcs->glUniformBlockBinding(programId, uniformBlockIndex, uniformBlockBinding);
@@ -1138,6 +967,100 @@ void GraphicsHelperGL3_3::glUniformMatrix4x3fv(GLint location, GLsizei count, co
     m_funcs->glUniformMatrix4x3fv(location, count, false, values);
 }
 
+UniformType GraphicsHelperGL3_3::uniformTypeFromGLType(GLenum type)
+{
+    switch (type) {
+    case GL_FLOAT:
+        return UniformType::Float;
+    case GL_FLOAT_VEC2:
+        return UniformType::Vec2;
+    case GL_FLOAT_VEC3:
+        return UniformType::Vec3;
+    case GL_FLOAT_VEC4:
+        return UniformType::Vec4;
+    case GL_FLOAT_MAT2:
+        return UniformType::Mat2;
+    case GL_FLOAT_MAT3:
+        return UniformType::Mat3;
+    case GL_FLOAT_MAT4:
+        return UniformType::Mat4;
+    case GL_FLOAT_MAT2x3:
+        return UniformType::Mat2x3;
+    case GL_FLOAT_MAT3x2:
+        return UniformType::Mat3x2;
+    case GL_FLOAT_MAT2x4:
+        return UniformType::Mat2x4;
+    case GL_FLOAT_MAT4x2:
+        return UniformType::Mat4x2;
+    case GL_FLOAT_MAT3x4:
+        return UniformType::Mat3x4;
+    case GL_FLOAT_MAT4x3:
+        return UniformType::Mat4x3;
+    case GL_INT:
+        return UniformType::Int;
+    case GL_INT_VEC2:
+        return UniformType::IVec2;
+    case GL_INT_VEC3:
+        return UniformType::IVec3;
+    case GL_INT_VEC4:
+        return UniformType::IVec4;
+    case GL_UNSIGNED_INT:
+        return UniformType::UInt;
+    case GL_UNSIGNED_INT_VEC2:
+        return UniformType::UIVec2;
+    case GL_UNSIGNED_INT_VEC3:
+        return UniformType::UIVec3;
+    case GL_UNSIGNED_INT_VEC4:
+        return UniformType::UIVec4;
+    case GL_BOOL:
+        return UniformType::Bool;
+    case GL_BOOL_VEC2:
+        return UniformType::BVec2;
+    case GL_BOOL_VEC3:
+        return UniformType::BVec3;
+    case GL_BOOL_VEC4:
+        return UniformType::BVec4;
+
+    case GL_SAMPLER_BUFFER:
+    case GL_SAMPLER_1D:
+    case GL_SAMPLER_1D_SHADOW:
+    case GL_SAMPLER_1D_ARRAY:
+    case GL_SAMPLER_2D:
+    case GL_SAMPLER_2D_RECT:
+    case GL_SAMPLER_2D_SHADOW:
+    case GL_SAMPLER_2D_RECT_SHADOW:
+    case GL_SAMPLER_CUBE:
+    case GL_SAMPLER_CUBE_SHADOW:
+    case GL_SAMPLER_2D_ARRAY:
+    case GL_SAMPLER_2D_ARRAY_SHADOW:
+    case GL_SAMPLER_2D_MULTISAMPLE:
+    case GL_SAMPLER_2D_MULTISAMPLE_ARRAY:
+    case GL_SAMPLER_3D:
+    case GL_INT_SAMPLER_BUFFER:
+    case GL_INT_SAMPLER_1D:
+    case GL_INT_SAMPLER_2D:
+    case GL_INT_SAMPLER_3D:
+    case GL_INT_SAMPLER_CUBE:
+    case GL_INT_SAMPLER_1D_ARRAY:
+    case GL_INT_SAMPLER_2D_ARRAY:
+    case GL_INT_SAMPLER_2D_MULTISAMPLE:
+    case GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
+    case GL_UNSIGNED_INT_SAMPLER_BUFFER:
+    case GL_UNSIGNED_INT_SAMPLER_1D:
+    case GL_UNSIGNED_INT_SAMPLER_2D:
+    case GL_UNSIGNED_INT_SAMPLER_3D:
+    case GL_UNSIGNED_INT_SAMPLER_CUBE:
+    case GL_UNSIGNED_INT_SAMPLER_1D_ARRAY:
+    case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
+    case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:
+    case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
+        return UniformType::Sampler;
+    default:
+        Q_UNREACHABLE();
+        return UniformType::Float;
+    }
+}
+
 } // namespace Render
 } // namespace Qt3DRender
 
diff --git a/src/render/graphicshelpers/graphicshelpergl3_3_p.h b/src/render/graphicshelpers/graphicshelpergl3_3_p.h
index de26f86f7..bbea8806a 100644
--- a/src/render/graphicshelpers/graphicshelpergl3_3_p.h
+++ b/src/render/graphicshelpers/graphicshelpergl3_3_p.h
@@ -64,10 +64,11 @@ class QOpenGLExtension_ARB_tessellation_shader;
 namespace Qt3DRender {
 namespace Render {
 
-class GraphicsHelperGL3_3 : public GraphicsHelperInterface
+class Q_AUTOTEST_EXPORT GraphicsHelperGL3_3 : public GraphicsHelperInterface
 {
 public:
     GraphicsHelperGL3_3();
+    ~GraphicsHelperGL3_3();
 
     // QGraphicHelperInterface interface
     void alphaTest(GLenum mode1, GLenum mode2) Q_DECL_OVERRIDE;
@@ -77,7 +78,6 @@ public:
     void bindFrameBufferObject(GLuint frameBufferId) Q_DECL_OVERRIDE;
     void bindShaderStorageBlock(GLuint programId, GLuint shaderStorageBlockIndex, GLuint shaderStorageBlockBinding) Q_DECL_OVERRIDE;
     void bindUniformBlock(GLuint programId, GLuint uniformBlockIndex, GLuint uniformBlockBinding) Q_DECL_OVERRIDE;
-    void bindUniform(const QVariant &v, const ShaderUniform &description) Q_DECL_OVERRIDE;
     void blendEquation(GLenum mode) Q_DECL_OVERRIDE;
     void blendFunci(GLuint buf, GLenum sfactor, GLenum dfactor) Q_DECL_OVERRIDE;
     void blendFuncSeparatei(GLuint buf, GLenum sRGB, GLenum dRGB, GLenum sAlpha, GLenum dAlpha) Q_DECL_OVERRIDE;
@@ -147,6 +147,8 @@ public:
     void glUniformMatrix3x4fv(GLint location, GLsizei count, const GLfloat *value) Q_DECL_OVERRIDE;
     void glUniformMatrix4x3fv(GLint location, GLsizei count, const GLfloat *value) Q_DECL_OVERRIDE;
 
+    UniformType uniformTypeFromGLType(GLenum glType) Q_DECL_OVERRIDE;
+
 private:
     QOpenGLFunctions_3_3_Core *m_funcs;
     QScopedPointer<QOpenGLExtension_ARB_tessellation_shader> m_tessFuncs;
diff --git a/src/render/graphicshelpers/graphicshelpergl3_p.h b/src/render/graphicshelpers/graphicshelpergl3_p.h
index 559b4c97d..3cc58bd26 100644
--- a/src/render/graphicshelpers/graphicshelpergl3_p.h
+++ b/src/render/graphicshelpers/graphicshelpergl3_p.h
@@ -77,7 +77,6 @@ public:
     void bindFrameBufferObject(GLuint frameBufferId) Q_DECL_OVERRIDE;
     void bindShaderStorageBlock(GLuint programId, GLuint shaderStorageBlockIndex, GLuint shaderStorageBlockBinding) Q_DECL_OVERRIDE;
     void bindUniformBlock(GLuint programId, GLuint uniformBlockIndex, GLuint uniformBlockBinding) Q_DECL_OVERRIDE;
-    void bindUniform(const QVariant &v, const ShaderUniform &description) Q_DECL_OVERRIDE;
     void blendEquation(GLenum mode) Q_DECL_OVERRIDE;
     void blendFunci(GLuint buf, GLenum sfactor, GLenum dfactor) Q_DECL_OVERRIDE;
     void blendFuncSeparatei(GLuint buf, GLenum sRGB, GLenum dRGB, GLenum sAlpha, GLenum dAlpha) Q_DECL_OVERRIDE;
@@ -147,6 +146,8 @@ public:
     void glUniformMatrix3x4fv(GLint location, GLsizei count, const GLfloat *value) Q_DECL_OVERRIDE;
     void glUniformMatrix4x3fv(GLint location, GLsizei count, const GLfloat *value) Q_DECL_OVERRIDE;
 
+    UniformType uniformTypeFromGLType(GLenum glType) Q_DECL_OVERRIDE;
+
 private:
     QOpenGLFunctions_3_2_Core *m_funcs;
     QScopedPointer<QOpenGLExtension_ARB_tessellation_shader> m_tessFuncs;
diff --git a/src/render/graphicshelpers/graphicshelpergl4.cpp b/src/render/graphicshelpers/graphicshelpergl4.cpp
index cd63bcd82..230b02a63 100644
--- a/src/render/graphicshelpers/graphicshelpergl4.cpp
+++ b/src/render/graphicshelpers/graphicshelpergl4.cpp
@@ -371,6 +371,105 @@ void GraphicsHelperGL4::glUniformMatrix4x3fv(GLint location, GLsizei count, cons
     m_funcs->glUniformMatrix4x3fv(location, count, false, values);
 }
 
+UniformType GraphicsHelperGL4::uniformTypeFromGLType(GLenum type)
+{
+    switch (type) {
+    case GL_FLOAT:
+        return UniformType::Float;
+    case GL_FLOAT_VEC2:
+        return UniformType::Vec2;
+    case GL_FLOAT_VEC3:
+        return UniformType::Vec3;
+    case GL_FLOAT_VEC4:
+        return UniformType::Vec4;
+    case GL_FLOAT_MAT2:
+        return UniformType::Mat2;
+    case GL_FLOAT_MAT3:
+        return UniformType::Mat3;
+    case GL_FLOAT_MAT4:
+        return UniformType::Mat4;
+    case GL_FLOAT_MAT2x3:
+        return UniformType::Mat2x3;
+    case GL_FLOAT_MAT3x2:
+        return UniformType::Mat3x2;
+    case GL_FLOAT_MAT2x4:
+        return UniformType::Mat2x4;
+    case GL_FLOAT_MAT4x2:
+        return UniformType::Mat4x2;
+    case GL_FLOAT_MAT3x4:
+        return UniformType::Mat3x4;
+    case GL_FLOAT_MAT4x3:
+        return UniformType::Mat4x3;
+    case GL_INT:
+        return UniformType::Int;
+    case GL_INT_VEC2:
+        return UniformType::IVec2;
+    case GL_INT_VEC3:
+        return UniformType::IVec3;
+    case GL_INT_VEC4:
+        return UniformType::IVec4;
+    case GL_UNSIGNED_INT:
+        return UniformType::UInt;
+    case GL_UNSIGNED_INT_VEC2:
+        return UniformType::UIVec2;
+    case GL_UNSIGNED_INT_VEC3:
+        return UniformType::UIVec3;
+    case GL_UNSIGNED_INT_VEC4:
+        return UniformType::UIVec4;
+    case GL_BOOL:
+        return UniformType::Bool;
+    case GL_BOOL_VEC2:
+        return UniformType::BVec2;
+    case GL_BOOL_VEC3:
+        return UniformType::BVec3;
+    case GL_BOOL_VEC4:
+        return UniformType::BVec4;
+
+    case GL_SAMPLER_1D:
+    case GL_SAMPLER_1D_ARRAY:
+    case GL_SAMPLER_1D_SHADOW:
+    case GL_SAMPLER_2D:
+    case GL_SAMPLER_2D_RECT:
+    case GL_SAMPLER_2D_SHADOW:
+    case GL_SAMPLER_2D_RECT_SHADOW:
+    case GL_SAMPLER_CUBE:
+    case GL_SAMPLER_CUBE_SHADOW:
+    case GL_SAMPLER_CUBE_MAP_ARRAY:
+    case GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW:
+    case GL_SAMPLER_2D_ARRAY:
+    case GL_SAMPLER_2D_ARRAY_SHADOW:
+    case GL_SAMPLER_2D_MULTISAMPLE:
+    case GL_SAMPLER_2D_MULTISAMPLE_ARRAY:
+    case GL_SAMPLER_3D:
+    case GL_SAMPLER_BUFFER:
+    case GL_INT_SAMPLER_1D:
+    case GL_INT_SAMPLER_2D:
+    case GL_INT_SAMPLER_3D:
+    case GL_INT_SAMPLER_BUFFER:
+    case GL_INT_SAMPLER_CUBE:
+    case GL_INT_SAMPLER_CUBE_MAP_ARRAY:
+    case GL_INT_SAMPLER_1D_ARRAY:
+    case GL_INT_SAMPLER_2D_ARRAY:
+    case GL_INT_SAMPLER_2D_MULTISAMPLE:
+    case GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
+    case GL_UNSIGNED_INT_SAMPLER_1D:
+    case GL_UNSIGNED_INT_SAMPLER_2D:
+    case GL_UNSIGNED_INT_SAMPLER_3D:
+    case GL_UNSIGNED_INT_SAMPLER_BUFFER:
+    case GL_UNSIGNED_INT_SAMPLER_1D_ARRAY:
+    case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
+    case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:
+    case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
+    case GL_UNSIGNED_INT_SAMPLER_CUBE:
+    case GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY:
+        return UniformType::Sampler;
+    default:
+        // TO DO: Add support for Doubles and Images
+        Q_UNREACHABLE();
+        return UniformType::Float;
+    }
+}
+
 void GraphicsHelperGL4::blendEquation(GLenum mode)
 {
     m_funcs->glBlendEquation(mode);
@@ -480,6 +579,8 @@ bool GraphicsHelperGL4::supportsFeature(GraphicsHelperInterface::Feature feature
     case MRT:
     case Tessellation:
     case UniformBufferObject:
+    case BindableFragmentOutputs:
+    case PrimitiveRestart:
     case RenderBufferDimensionRetrieval:
     case TextureDimensionRetrieval:
     case ShaderStorageObject:
@@ -507,182 +608,6 @@ void GraphicsHelperGL4::bindFragDataLocation(GLuint shader, const QHash<QString,
         m_funcs->glBindFragDataLocation(shader, it.value(), it.key().toStdString().c_str());
 }
 
-void GraphicsHelperGL4::bindUniform(const QVariant &v, const ShaderUniform &description)
-{
-    switch (description.m_type) {
-
-    case GL_FLOAT:
-        m_funcs->glUniform1fv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 1));
-        break;
-
-    case GL_FLOAT_VEC2:
-        m_funcs->glUniform2fv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 2));
-        break;
-
-    case GL_FLOAT_VEC3:
-        m_funcs->glUniform3fv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 3));
-        break;
-
-    case GL_FLOAT_VEC4:
-        m_funcs->glUniform4fv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 4));
-        break;
-
-    case GL_FLOAT_MAT2:
-        m_funcs->glUniformMatrix2fv(description.m_location, description.m_size, GL_FALSE,
-                                    QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 4));
-        break;
-
-    case GL_FLOAT_MAT2x3:
-        m_funcs->glUniformMatrix2x3fv(description.m_location, description.m_size, GL_FALSE,
-                                      QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 6));
-        break;
-
-    case GL_FLOAT_MAT2x4:
-        m_funcs->glUniformMatrix2x4fv(description.m_location, description.m_size, GL_FALSE,
-                                      QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 8));
-        break;
-
-    case GL_FLOAT_MAT3:
-        m_funcs->glUniformMatrix3fv(description.m_location, description.m_size, GL_FALSE,
-                                    QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 9));
-        break;
-
-    case GL_FLOAT_MAT3x2:
-        m_funcs->glUniformMatrix3x2fv(description.m_location, description.m_size,  GL_FALSE,
-                                      QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 6));
-        break;
-
-    case GL_FLOAT_MAT3x4:
-        m_funcs->glUniformMatrix3x4fv(description.m_location, description.m_size, GL_FALSE,
-                                      QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 12));
-        break;
-
-    case GL_FLOAT_MAT4:
-        m_funcs->glUniformMatrix4fv(description.m_location, description.m_size, GL_FALSE,
-                                    QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 16));
-        break;
-
-    case GL_FLOAT_MAT4x2:
-        m_funcs->glUniformMatrix4x2fv(description.m_location, description.m_size, GL_FALSE,
-                                      QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 8));
-        break;
-
-    case GL_FLOAT_MAT4x3:
-        m_funcs->glUniformMatrix4x3fv(description.m_location, description.m_size, GL_FALSE,
-                                      QGraphicsUtils::valueArrayFromVariant<GLfloat>(v, description.m_size, 12));
-        break;
-
-    case GL_INT:
-        m_funcs->glUniform1iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 1));
-        break;
-
-    case GL_INT_VEC2:
-        m_funcs->glUniform2iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 2));
-        break;
-
-    case GL_INT_VEC3:
-        m_funcs->glUniform3iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 3));
-        break;
-
-    case GL_INT_VEC4:
-        m_funcs->glUniform4iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 4));
-        break;
-
-    case GL_UNSIGNED_INT:
-        m_funcs->glUniform1uiv(description.m_location, description.m_size,
-                               QGraphicsUtils::valueArrayFromVariant<GLuint>(v, description.m_size, 1));
-        break;
-
-    case GL_UNSIGNED_INT_VEC2:
-        m_funcs->glUniform2uiv(description.m_location, description.m_size,
-                               QGraphicsUtils::valueArrayFromVariant<GLuint>(v, description.m_size, 2));
-        break;
-
-    case GL_UNSIGNED_INT_VEC3:
-        m_funcs->glUniform3uiv(description.m_location, description.m_size,
-                               QGraphicsUtils::valueArrayFromVariant<GLuint>(v, description.m_size, 3));
-        break;
-
-    case GL_UNSIGNED_INT_VEC4:
-        m_funcs->glUniform4uiv(description.m_location, description.m_size,
-                               QGraphicsUtils::valueArrayFromVariant<GLuint>(v, description.m_size, 4));
-        break;
-
-    case GL_BOOL:
-        m_funcs->glUniform1iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 1));
-        break;
-
-    case GL_BOOL_VEC2:
-        m_funcs->glUniform2iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 2));
-        break;
-
-    case GL_BOOL_VEC3:
-        m_funcs->glUniform3iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 3));
-        break;
-
-    case GL_BOOL_VEC4:
-        m_funcs->glUniform4iv(description.m_location, description.m_size,
-                              QGraphicsUtils::valueArrayFromVariant<GLint>(v, description.m_size, 4));
-        break;
-
-    case GL_SAMPLER_1D:
-    case GL_SAMPLER_2D:
-    case GL_SAMPLER_3D:
-    case GL_SAMPLER_CUBE:
-    case GL_SAMPLER_BUFFER:
-    case GL_SAMPLER_2D_RECT:
-    case GL_INT_SAMPLER_1D:
-    case GL_INT_SAMPLER_2D:
-    case GL_INT_SAMPLER_3D:
-    case GL_INT_SAMPLER_CUBE:
-    case GL_INT_SAMPLER_BUFFER:
-    case GL_INT_SAMPLER_2D_RECT:
-    case GL_UNSIGNED_INT_SAMPLER_1D:
-    case GL_UNSIGNED_INT_SAMPLER_2D:
-    case GL_UNSIGNED_INT_SAMPLER_3D:
-    case GL_UNSIGNED_INT_SAMPLER_CUBE:
-    case GL_UNSIGNED_INT_SAMPLER_BUFFER:
-    case GL_UNSIGNED_INT_SAMPLER_2D_RECT:
-    case GL_SAMPLER_1D_SHADOW:
-    case GL_SAMPLER_2D_SHADOW:
-    case GL_SAMPLER_CUBE_SHADOW:
-    case GL_SAMPLER_1D_ARRAY:
-    case GL_SAMPLER_2D_ARRAY:
-    case GL_INT_SAMPLER_1D_ARRAY:
-    case GL_INT_SAMPLER_2D_ARRAY:
-    case GL_UNSIGNED_INT_SAMPLER_1D_ARRAY:
-    case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
-    case GL_SAMPLER_1D_ARRAY_SHADOW:
-    case GL_SAMPLER_2D_ARRAY_SHADOW:
-    case GL_SAMPLER_2D_RECT_SHADOW:
-    case GL_SAMPLER_2D_MULTISAMPLE:
-    case GL_INT_SAMPLER_2D_MULTISAMPLE:
-    case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:
-    case GL_SAMPLER_2D_MULTISAMPLE_ARRAY:
-    case GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
-    case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY: {
-        Q_ASSERT(description.m_size == 1);
-        m_funcs->glUniform1i(description.m_location, v.toInt());
-        break;
-    }
-
-    default:
-        qWarning() << Q_FUNC_INFO << "unsupported uniform type:" << description.m_type << "for " << description.m_name;
-        break;
-    }
-}
-
 void GraphicsHelperGL4::bindUniformBlock(GLuint programId, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
 {
     m_funcs->glUniformBlockBinding(programId, uniformBlockIndex, uniformBlockBinding);
diff --git a/src/render/graphicshelpers/graphicshelpergl4_p.h b/src/render/graphicshelpers/graphicshelpergl4_p.h
index 0333b4258..ad4875f2e 100644
--- a/src/render/graphicshelpers/graphicshelpergl4_p.h
+++ b/src/render/graphicshelpers/graphicshelpergl4_p.h
@@ -76,7 +76,6 @@ public:
     void bindFrameBufferObject(GLuint frameBufferId) Q_DECL_OVERRIDE;
     void bindShaderStorageBlock(GLuint programId, GLuint shaderStorageBlockIndex, GLuint shaderStorageBlockBinding) Q_DECL_OVERRIDE;
     void bindUniformBlock(GLuint programId, GLuint uniformBlockIndex, GLuint uniformBlockBinding) Q_DECL_OVERRIDE;
-    void bindUniform(const QVariant &v, const ShaderUniform &description) Q_DECL_OVERRIDE;
     void blendEquation(GLenum mode) Q_DECL_OVERRIDE;
     void blendFunci(GLuint buf, GLenum sfactor, GLenum dfactor) Q_DECL_OVERRIDE;
     void blendFuncSeparatei(GLuint buf, GLenum sRGB, GLenum dRGB, GLenum sAlpha, GLenum dAlpha) Q_DECL_OVERRIDE;
@@ -146,6 +145,8 @@ public:
     void glUniformMatrix3x4fv(GLint location, GLsizei count, const GLfloat *value) Q_DECL_OVERRIDE;
     void glUniformMatrix4x3fv(GLint location, GLsizei count, const GLfloat *value) Q_DECL_OVERRIDE;
 
+    UniformType uniformTypeFromGLType(GLenum glType) Q_DECL_OVERRIDE;
+
 private:
     QOpenGLFunctions_4_3_Core *m_funcs;
 };
diff --git a/src/render/graphicshelpers/graphicshelperinterface_p.h b/src/render/graphicshelpers/graphicshelperinterface_p.h
index 355c8f429..1a7199a2c 100644
--- a/src/render/graphicshelpers/graphicshelperinterface_p.h
+++ b/src/render/graphicshelpers/graphicshelperinterface_p.h
@@ -55,6 +55,7 @@
 #include <QOpenGLTexture>
 #include <QVector>
 #include <Qt3DRender/private/shadervariables_p.h>
+#include <Qt3DRender/private/uniform_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -87,7 +88,6 @@ public:
     virtual void    bindFrameBufferObject(GLuint frameBufferId) = 0;
     virtual void    bindShaderStorageBlock(GLuint programId, GLuint shaderStorageBlockIndex, GLuint shaderStorageBlockBinding) = 0;
     virtual void    bindUniformBlock(GLuint programId, GLuint uniformBlockIndex, GLuint uniformBlockBinding) = 0;
-    virtual void    bindUniform(const QVariant &v, const ShaderUniform &description) = 0;
     virtual void    blendEquation(GLenum mode) = 0;
     virtual void    blendFunci(GLuint buf, GLenum sfactor, GLenum dfactor) = 0;
     virtual void    blendFuncSeparatei(GLuint buf, GLenum sRGB, GLenum dRGB, GLenum sAlpha, GLenum dAlpha) = 0;
@@ -157,6 +157,7 @@ public:
     virtual void glUniformMatrix3x4fv(GLint location, GLsizei count, const GLfloat *value) = 0;
     virtual void glUniformMatrix4x3fv(GLint location, GLsizei count, const GLfloat *value) = 0;
 
+    virtual UniformType uniformTypeFromGLType(GLenum glType) = 0;
 };