Renderer: get rid of QVariant for backend uniforms

Change-Id: Ib4d6f178ec2f6bb19f26e09ad74ba77d2c752627
Reviewed-by: Sean Harmer <sean.harmer@kdab.com>

9 files changed, 203 insertions, 243 deletions

diff --git a/src/render/backend/commandexecuter.cpp b/src/render/backend/commandexecuter.cpp
index 92f44c511..2f13b27ea 100644
--- a/src/render/backend/commandexecuter.cpp
+++ b/src/render/backend/commandexecuter.cpp
@@ -251,13 +251,9 @@ QJsonObject parameterPackToJson(const Render::ShaderParameterPack &pack)
     for (auto it = uniforms.cbegin(), end = uniforms.cend(); it != end; ++it) {
         QJsonObject uniformObj;
         uniformObj.insert(QLatin1String("name"), Render::StringToInt::lookupString(it.key()));
-        const Render::QUniformValue::UniformType type = it.value().type();
-        uniformObj.insert(QLatin1String("value"),
-                          type == Render::QUniformValue::Value
-                          ? typeToJsonValue(it.value().value())
-                          : typeToJsonValue(it.value().textureId()));
+        const Render::UniformValue::ValueType type = it.value().valueType();
         uniformObj.insert(QLatin1String("type"),
-                          type == Render::QUniformValue::Value
+                          type == Render::UniformValue::ScalarValue
                           ? QLatin1String("value")
                           : QLatin1String("texture"));
         uniformsArray.push_back(uniformObj);
diff --git a/src/render/backend/quniformvalue.cpp b/src/render/backend/quniformvalue.cpp
index 09327c213..b7eaf2023 100644
--- a/src/render/backend/quniformvalue.cpp
+++ b/src/render/backend/quniformvalue.cpp
@@ -55,42 +55,12 @@ QT_BEGIN_NAMESPACE
 namespace Qt3DRender {
 namespace Render {
 
-void QUniformValue::apply(GraphicsContext *ctx, const ShaderUniform &description) const
-{
-    switch (m_type) {
-    case Value:
-        ctx->bindUniform(m_var, description);
-        break;
-
-    case TextureSampler:
-        // We assume that the texture has been successfully bound and attache to a texture unit
-        if (m_textureIdUnit.m_textureUnit != -1) {
-            ctx->bindUniform(m_textureIdUnit.m_textureUnit, description);
-#if defined(QT3D_RENDER_ASPECT_OPENGL_DEBUG)
-            int err = ctx->openGLContext()->functions()->glGetError();
-            if (err) {
-                qCWarning(Render::Backend, "Error %d after setting uniform \"%s\" at location %d",
-                          err, qUtf8Printable(description.m_name), description.m_location);
-            }
-#endif
-        } else {
-            qCWarning(Render::Backend, "Invalid texture unit supplied for \"%s\"",
-                      qUtf8Printable(description.m_nameId));
-        }
-        break;
-
-    default:
-        break;
-    }
-}
-
-
 ShaderParameterPack::~ShaderParameterPack()
 {
     m_uniforms.clear();
 }
 
-void ShaderParameterPack::setUniform(const int glslNameId, const QUniformValue &val)
+void ShaderParameterPack::setUniform(const int glslNameId, const UniformValue &val)
 {
     m_uniforms.insert(glslNameId, val);
 }
diff --git a/src/render/backend/quniformvalue_p.h b/src/render/backend/quniformvalue_p.h
index fb8158d84..50a97c6b7 100644
--- a/src/render/backend/quniformvalue_p.h
+++ b/src/render/backend/quniformvalue_p.h
@@ -58,6 +58,7 @@
 #include <Qt3DCore/qnodeid.h>
 #include <Qt3DRender/private/renderlogging_p.h>
 #include <Qt3DRender/private/shadervariables_p.h>
+#include <Qt3DRender/private/uniform_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -72,118 +73,6 @@ namespace Render {
 
 class GraphicsContext;
 
-class QUniformValue
-{
-public:
-    enum UniformType {
-        Value,
-        TextureSampler,
-        Unknown
-    };
-
-    QUniformValue()
-        : m_type(Unknown)
-        , m_var()
-    {
-    }
-
-    explicit QUniformValue(const QVariant &var, UniformType type = Value)
-        : m_type(type)
-        , m_var(var)
-    {
-    }
-
-    void setType(UniformType type) Q_DECL_NOTHROW { m_type = type; }
-    UniformType type() const Q_DECL_NOTHROW { return m_type; }
-    bool isTexture() const Q_DECL_NOTHROW { return m_type == TextureSampler; }
-
-    void setValue(const QVariant &value)
-    {
-        Q_ASSERT(m_type == Value);
-        m_var = value;
-    }
-
-    QVariant value() const
-    {
-        Q_ASSERT(m_type == Value);
-        return m_var;
-    }
-
-    void setTextureUnit(int textureUnit)
-    {
-        Q_ASSERT(m_type == TextureSampler);
-        m_textureIdUnit.m_textureUnit = textureUnit;
-    }
-
-    int textureUnit() const
-    {
-        Q_ASSERT(m_type == TextureSampler);
-        return m_textureIdUnit.m_textureUnit;
-    }
-
-    void setTextureId(Qt3DCore::QNodeId textureId)
-    {
-        Q_ASSERT(m_type == TextureSampler);
-        m_textureIdUnit.m_textureId = textureId;
-    }
-
-    Qt3DCore::QNodeId textureId() const
-    {
-        Q_ASSERT(m_type == TextureSampler);
-        return m_textureIdUnit.m_textureId;
-    }
-
-    bool operator ==(const QUniformValue &other)
-    {
-        if (other.m_type != m_type)
-            return false;
-
-        switch (m_type) {
-        case Value:
-            return other.m_var == m_var;
-        case TextureSampler:
-            return other.m_textureIdUnit == m_textureIdUnit;
-        default:
-            break;
-        }
-        return false;
-    }
-
-    bool operator !=(const QUniformValue &other)
-    {
-        return !operator ==(other);
-    }
-
-    void apply(GraphicsContext *ctx, const ShaderUniform &description) const;
-
-protected:
-    struct TextureIdUnit {
-        Qt3DCore::QNodeId m_textureId;
-        int m_textureUnit;
-
-        TextureIdUnit()
-            : m_textureId()
-            , m_textureUnit(-1)
-        {}
-
-        bool operator == (const TextureIdUnit &other) const Q_DECL_NOTHROW
-        {
-            return (other.m_textureId == m_textureId) && (other.m_textureUnit == m_textureUnit);
-        }
-
-        bool operator !=(const TextureIdUnit &other) const Q_DECL_NOTHROW
-        {
-            return !operator ==(other);
-        }
-    };
-
-    // TODO: Replace QVariant with our own union of GLSL types as we don't
-    // need the full flexibility of QVariant on the backend
-    UniformType m_type;
-    QVariant m_var;
-    TextureIdUnit m_textureIdUnit;
-};
-
 struct BlockToUBO {
     int m_blockIndex;
     Qt3DCore::QNodeId m_bufferID;
@@ -199,14 +88,14 @@ struct BlockToSSBO {
 QT3D_DECLARE_TYPEINFO_2(Qt3DRender, Render, BlockToSSBO, Q_PRIMITIVE_TYPE)
 
 
-typedef QHash<int, QUniformValue> PackUniformHash;
+typedef QHash<int, UniformValue> PackUniformHash;
 
 class ShaderParameterPack
 {
 public:
     ~ShaderParameterPack();
 
-    void setUniform(const int glslNameId, const QUniformValue &val);
+    void setUniform(const int glslNameId, const UniformValue &val);
     void setTexture(const int glslNameId, Qt3DCore::QNodeId id);
     void setUniformBuffer(BlockToUBO blockToUBO);
     void setShaderStorageBuffer(BlockToSSBO blockToSSBO);
@@ -214,7 +103,7 @@ public:
 
     inline PackUniformHash &uniforms() { return m_uniforms; }
     inline const PackUniformHash &uniforms() const { return m_uniforms; }
-    QUniformValue uniform(const int glslNameId) const { return m_uniforms.value(glslNameId); }
+    UniformValue uniform(const int glslNameId) const { return m_uniforms.value(glslNameId); }
 
     struct NamedTexture
     {
diff --git a/src/render/backend/renderview.cpp b/src/render/backend/renderview.cpp
index 552e66f6d..8594f2d20 100644
--- a/src/render/backend/renderview.cpp
+++ b/src/render/backend/renderview.cpp
@@ -133,80 +133,80 @@ RenderView::StandardUniformsPFuncsHash RenderView::initializeStandardUniformSett
     return setters;
 }
 
-QUniformValue RenderView::modelMatrix(const QMatrix4x4 &model) const
+UniformValue RenderView::modelMatrix(const QMatrix4x4 &model) const
 {
-    return QUniformValue(QVariant::fromValue(model));
+    return UniformValue(model);
 }
 
-QUniformValue RenderView::viewMatrix(const QMatrix4x4 &) const
+UniformValue RenderView::viewMatrix(const QMatrix4x4 &) const
 {
-    return QUniformValue(QVariant::fromValue(m_data.m_viewMatrix));
+    return UniformValue(m_data.m_viewMatrix);
 }
 
-QUniformValue RenderView::projectionMatrix(const QMatrix4x4 &) const
+UniformValue RenderView::projectionMatrix(const QMatrix4x4 &) const
 {
-    return QUniformValue(QVariant::fromValue(m_data.m_renderCameraLens->projection()));
+    return UniformValue(m_data.m_renderCameraLens->projection());
 }
 
-QUniformValue RenderView::modelViewMatrix(const QMatrix4x4 &model) const
+UniformValue RenderView::modelViewMatrix(const QMatrix4x4 &model) const
 {
-    return QUniformValue(QVariant::fromValue(m_data.m_viewMatrix * model));
+    return UniformValue(m_data.m_viewMatrix * model);
 }
 
-QUniformValue RenderView::viewProjectionMatrix(const QMatrix4x4 &model) const
+UniformValue RenderView::viewProjectionMatrix(const QMatrix4x4 &model) const
 {
     Q_UNUSED(model);
-    return QUniformValue(QVariant::fromValue(m_data.m_renderCameraLens->projection() * m_data.m_viewMatrix));
+    return UniformValue(m_data.m_renderCameraLens->projection() * m_data.m_viewMatrix);
 }
 
-QUniformValue RenderView::modelViewProjectionMatrix(const QMatrix4x4 &model) const
+UniformValue RenderView::modelViewProjectionMatrix(const QMatrix4x4 &model) const
 {
-    return QUniformValue(QVariant::fromValue(m_data.m_viewProjectionMatrix * model));
+    return UniformValue(m_data.m_viewProjectionMatrix * model);
 }
 
-QUniformValue RenderView::inverseModelMatrix(const QMatrix4x4 &model) const
+UniformValue RenderView::inverseModelMatrix(const QMatrix4x4 &model) const
 {
-    return QUniformValue(QVariant::fromValue(model.inverted()));
+    return UniformValue(model.inverted());
 }
 
-QUniformValue RenderView::inverseViewMatrix(const QMatrix4x4 &) const
+UniformValue RenderView::inverseViewMatrix(const QMatrix4x4 &) const
 {
-    return QUniformValue(QVariant::fromValue(m_data.m_viewMatrix.inverted()));
+    return UniformValue(m_data.m_viewMatrix.inverted());
 }
 
-QUniformValue RenderView::inverseProjectionMatrix(const QMatrix4x4 &) const
+UniformValue RenderView::inverseProjectionMatrix(const QMatrix4x4 &) const
 {
     QMatrix4x4 projection;
     if (m_data.m_renderCameraLens)
         projection = m_data.m_renderCameraLens->projection();
-    return QUniformValue(QVariant::fromValue(projection.inverted()));
+    return UniformValue(projection.inverted());
 }
 
-QUniformValue RenderView::inverseModelViewMatrix(const QMatrix4x4 &model) const
+UniformValue RenderView::inverseModelViewMatrix(const QMatrix4x4 &model) const
 {
-    return QUniformValue(QVariant::fromValue((m_data.m_viewMatrix * model).inverted()));
+    return UniformValue((m_data.m_viewMatrix * model).inverted());
 }
 
-QUniformValue RenderView::inverseViewProjectionMatrix(const QMatrix4x4 &model) const
+UniformValue RenderView::inverseViewProjectionMatrix(const QMatrix4x4 &model) const
 {
     Q_UNUSED(model);
     const auto viewProjectionMatrix = m_data.m_renderCameraLens->projection() * m_data.m_viewMatrix;
-    return QUniformValue(QVariant::fromValue(viewProjectionMatrix.inverted()));
+    return UniformValue(viewProjectionMatrix.inverted());
 }
 
-QUniformValue RenderView::inverseModelViewProjectionMatrix(const QMatrix4x4 &model) const
+UniformValue RenderView::inverseModelViewProjectionMatrix(const QMatrix4x4 &model) const
 {
-    return QUniformValue(QVariant::fromValue((m_data.m_viewProjectionMatrix * model).inverted(0)));
+    return UniformValue((m_data.m_viewProjectionMatrix * model).inverted(0));
 }
 
-QUniformValue RenderView::modelNormalMatrix(const QMatrix4x4 &model) const
+UniformValue RenderView::modelNormalMatrix(const QMatrix4x4 &model) const
 {
-    return QUniformValue(QVariant::fromValue(model.normalMatrix()));
+    return UniformValue(model.normalMatrix());
 }
 
-QUniformValue RenderView::modelViewNormalMatrix(const QMatrix4x4 &model) const
+UniformValue RenderView::modelViewNormalMatrix(const QMatrix4x4 &model) const
 {
-    return QUniformValue(QVariant::fromValue((m_data.m_viewMatrix * model).normalMatrix()));
+    return UniformValue((m_data.m_viewMatrix * model).normalMatrix());
 }
 
 // TODO: Move this somewhere global where GraphicsContext::setViewport() can use it too
@@ -218,38 +218,38 @@ static QRectF resolveViewport(const QRectF &fractionalViewport, const QSize &sur
                   fractionalViewport.height() * surfaceSize.height());
 }
 
-QUniformValue RenderView::viewportMatrix(const QMatrix4x4 &model) const
+UniformValue RenderView::viewportMatrix(const QMatrix4x4 &model) const
 {
     // TODO: Can we avoid having to pass the model matrix in to these functions?
     Q_UNUSED(model);
     QMatrix4x4 viewportMatrix;
     viewportMatrix.viewport(resolveViewport(m_viewport, m_surfaceSize));
-    return QUniformValue(QVariant::fromValue(viewportMatrix));
+    return UniformValue(viewportMatrix);
 
 }
 
-QUniformValue RenderView::inverseViewportMatrix(const QMatrix4x4 &model) const
+UniformValue RenderView::inverseViewportMatrix(const QMatrix4x4 &model) const
 {
     Q_UNUSED(model);
     QMatrix4x4 viewportMatrix;
     viewportMatrix.viewport(resolveViewport(m_viewport, m_surfaceSize));
     QMatrix4x4 inverseViewportMatrix = viewportMatrix.inverted();
-    return QUniformValue(QVariant::fromValue(inverseViewportMatrix));
+    return UniformValue(inverseViewportMatrix);
 
 }
 
-QUniformValue RenderView::time(const QMatrix4x4 &model) const
+UniformValue RenderView::time(const QMatrix4x4 &model) const
 {
     Q_UNUSED(model);
     qint64 time = m_renderer->time();
     float t = time / 1000000000.0f;
-    return QUniformValue(QVariant(t));
+    return UniformValue(t);
 }
 
-QUniformValue RenderView::eyePosition(const QMatrix4x4 &model) const
+UniformValue RenderView::eyePosition(const QMatrix4x4 &model) const
 {
     Q_UNUSED(model);
-    return QUniformValue(QVariant::fromValue(m_data.m_eyePos));
+    return UniformValue(m_data.m_eyePos);
 }
 
 RenderView::RenderView()
@@ -326,7 +326,7 @@ void RenderView::sort()
                     // sharing the same material (shader) are rendered, we can't have the case
                     // where two uniforms, referencing the same texture eventually have 2 different
                     // texture unit values
-                    const QUniformValue refValue = cachedUniforms.value(it.key());
+                    const UniformValue refValue = cachedUniforms.value(it.key());
                     if (it.value() == refValue) {
                         it = uniforms.erase(it);
                     } else {
@@ -532,27 +532,24 @@ void RenderView::updateMatrices()
     }
 }
 
-void RenderView::setUniformValue(ShaderParameterPack &uniformPack, int nameId, const QVariant &value) const
+void RenderView::setUniformValue(ShaderParameterPack &uniformPack, int nameId, const UniformValue &value) const
 {
-    Texture *tex = nullptr;
     // At this point a uniform value can only be a scalar type
     // or a Qt3DCore::QNodeId corresponding to a Texture
     // ShaderData/Buffers would be handled as UBO/SSBO and would therefore
     // not be in the default uniform block
-    if (static_cast<QMetaType::Type>(value.userType()) == qNodeIdTypeId) {
-        // Speed up conversion to avoid using QVariant::value()
-        const Qt3DCore::QNodeId texId = variant_value<Qt3DCore::QNodeId>(value);
+    if (value.valueType() == UniformValue::NodeId) {
+        Texture *tex = nullptr;
+        const Qt3DCore::QNodeId texId = *value.constData<Qt3DCore::QNodeId>();
         if ((tex = m_manager->textureManager()->lookupResource(texId))
                 != nullptr) {
             uniformPack.setTexture(nameId, tex->peerId());
-            //TextureUniform *texUniform = m_allocator->allocate<TextureUniform>();
-            QUniformValue texUniform;
-            texUniform.setType(QUniformValue::TextureSampler);
-            texUniform.setTextureId(tex->peerId());
-            uniformPack.setUniform(nameId, texUniform);
+            UniformValue::Texture textureValue;
+            textureValue.nodeId = texId;
+            uniformPack.setUniform(nameId, UniformValue(textureValue));
         }
     } else {
-        uniformPack.setUniform(nameId, QUniformValue(value));
+        uniformPack.setUniform(nameId, value);
     }
 }
 
@@ -564,14 +561,14 @@ void RenderView::setStandardUniformValue(ShaderParameterPack &uniformPack, int g
 void RenderView::setUniformBlockValue(ShaderParameterPack &uniformPack,
                                       Shader *shader,
                                       const ShaderUniformBlock &block,
-                                      const QVariant &value) const
+                                      const UniformValue &value) const
 {
     Q_UNUSED(shader)
 
-    if (static_cast<QMetaType::Type>(value.userType()) == qNodeIdTypeId) {
+    if (value.valueType() == UniformValue::NodeId) {
 
         Buffer *buffer = nullptr;
-        if ((buffer = m_manager->bufferManager()->lookupResource(variant_value<Qt3DCore::QNodeId>(value))) != nullptr) {
+        if ((buffer = m_manager->bufferManager()->lookupResource(*value.constData<Qt3DCore::QNodeId>())) != nullptr) {
             BlockToUBO uniformBlockUBO;
             uniformBlockUBO.m_blockIndex = block.m_index;
             uniformBlockUBO.m_bufferID = buffer->peerId();
@@ -634,12 +631,12 @@ void RenderView::setUniformBlockValue(ShaderParameterPack &uniformPack,
 void RenderView::setShaderStorageValue(ShaderParameterPack &uniformPack,
                                        Shader *shader,
                                        const ShaderStorageBlock &block,
-                                       const QVariant &value) const
+                                       const UniformValue &value) const
 {
     Q_UNUSED(shader)
-    if (static_cast<QMetaType::Type>(value.userType()) == qNodeIdTypeId) {
+    if (value.valueType() == UniformValue::NodeId) {
         Buffer *buffer = nullptr;
-        if ((buffer = m_manager->bufferManager()->lookupResource(variant_value<Qt3DCore::QNodeId>(value))) != nullptr) {
+        if ((buffer = m_manager->bufferManager()->lookupResource(*value.constData<Qt3DCore::QNodeId>())) != nullptr) {
             BlockToSSBO shaderStorageBlock;
             shaderStorageBlock.m_blockIndex = block.m_index;
             shaderStorageBlock.m_bufferID = buffer->peerId();
@@ -668,8 +665,9 @@ void RenderView::setDefaultUniformBlockShaderDataValue(ShaderParameterPack &unif
     QHash<int, QVariant>::const_iterator activeValuesIt = builder->activeUniformNamesToValue.constBegin();
     const QHash<int, QVariant>::const_iterator activeValuesEnd = builder->activeUniformNamesToValue.constEnd();
 
+    // TO DO: Make the ShaderData store UniformValue
     while (activeValuesIt != activeValuesEnd) {
-        setUniformValue(uniformPack, activeValuesIt.key(), activeValuesIt.value());
+        setUniformValue(uniformPack, activeValuesIt.key(), UniformValue::fromVariant(activeValuesIt.value()));
         ++activeValuesIt;
     }
 }
@@ -769,10 +767,10 @@ void RenderView::setShaderAndUniforms(RenderCommand *command, RenderPass *rPass,
                     } else if (shaderStorageBlockNamesIds.indexOf(it->nameId) != -1) { // Parameters is a SSBO
                         setShaderStorageValue(command->m_parameterPack, shader, shader->storageBlockForBlockNameId(it->nameId), it->value);
                     } else { // Parameter is a struct
-                        const QVariant &v = it->value;
+                        const UniformValue &v = it->value;
                         ShaderData *shaderData = nullptr;
-                        if (static_cast<QMetaType::Type>(v.userType()) == qNodeIdTypeId &&
-                                (shaderData = m_manager->shaderDataManager()->lookupResource(variant_value<Qt3DCore::QNodeId>(v))) != nullptr) {
+                        if (v.valueType() == UniformValue::NodeId &&
+                                (shaderData = m_manager->shaderDataManager()->lookupResource(*v.constData<Qt3DCore::QNodeId>())) != nullptr) {
                             // Try to check if we have a struct or array matching a QShaderData parameter
                             setDefaultUniformBlockShaderDataValue(command->m_parameterPack, shader, shaderData, StringToInt::lookupString(it->nameId));
                         }
@@ -797,6 +795,7 @@ void RenderView::setShaderAndUniforms(RenderCommand *command, RenderPass *rPass,
                         if (lightIdx == MAX_LIGHTS)
                             break;
 
+                        // Note: implicit conversion of values to UniformValue
                         setUniformValue(command->m_parameterPack, LIGHT_POSITION_NAMES[lightIdx], worldPos);
                         setUniformValue(command->m_parameterPack, LIGHT_TYPE_NAMES[lightIdx], int(QAbstractLight::PointLight));
                         setUniformValue(command->m_parameterPack, LIGHT_COLOR_NAMES[lightIdx], QVector3D(1.0f, 1.0f, 1.0f));
@@ -812,9 +811,10 @@ void RenderView::setShaderAndUniforms(RenderCommand *command, RenderPass *rPass,
                 }
 
                 if (uniformNamesIds.contains(LIGHT_COUNT_NAME_ID))
-                    setUniformValue(command->m_parameterPack, LIGHT_COUNT_NAME_ID, qMax(1, lightIdx));
+                    setUniformValue(command->m_parameterPack, LIGHT_COUNT_NAME_ID, UniformValue(qMax(1, lightIdx)));
 
                 if (activeLightSources.isEmpty()) {
+                    // Note: implicit conversion of values to UniformValue
                     setUniformValue(command->m_parameterPack, LIGHT_POSITION_NAMES[0], QVector3D(10.0f, 10.0f, 0.0f));
                     setUniformValue(command->m_parameterPack, LIGHT_TYPE_NAMES[0], int(QAbstractLight::PointLight));
                     setUniformValue(command->m_parameterPack, LIGHT_COLOR_NAMES[0], QVector3D(1.0f, 1.0f, 1.0f));
diff --git a/src/render/backend/renderview_p.h b/src/render/backend/renderview_p.h
index f974741aa..41b0192c0 100644
--- a/src/render/backend/renderview_p.h
+++ b/src/render/backend/renderview_p.h
@@ -279,39 +279,39 @@ private:
 
     QHash<Qt3DCore::QNodeId, QVector<RenderPassParameterData>> m_parameters;
 
-    typedef QHash<int, QUniformValue (RenderView::*)(const QMatrix4x4& model) const> StandardUniformsPFuncsHash;
+    typedef QHash<int, UniformValue (RenderView::*)(const QMatrix4x4& model) const> StandardUniformsPFuncsHash;
     static StandardUniformsPFuncsHash ms_standardUniformSetters;
     static StandardUniformsPFuncsHash initializeStandardUniformSetters();
 
-    QUniformValue modelMatrix(const QMatrix4x4& model) const;
-    QUniformValue viewMatrix(const QMatrix4x4&) const;
-    QUniformValue projectionMatrix(const QMatrix4x4 &) const;
-    QUniformValue modelViewMatrix(const QMatrix4x4 &model) const;
-    QUniformValue viewProjectionMatrix(const QMatrix4x4 &model) const;
-    QUniformValue modelViewProjectionMatrix(const QMatrix4x4 &model) const;
-    QUniformValue inverseModelMatrix(const QMatrix4x4 &model) const;
-    QUniformValue inverseViewMatrix(const QMatrix4x4 &) const;
-    QUniformValue inverseProjectionMatrix(const QMatrix4x4 &) const;
-    QUniformValue inverseModelViewMatrix(const QMatrix4x4 &model) const;
-    QUniformValue inverseViewProjectionMatrix(const QMatrix4x4 &model) const;
-    QUniformValue inverseModelViewProjectionMatrix(const QMatrix4x4 &model) const;
-    QUniformValue modelNormalMatrix(const QMatrix4x4 &model) const;
-    QUniformValue modelViewNormalMatrix(const QMatrix4x4 &model) const;
-    QUniformValue viewportMatrix(const QMatrix4x4 &model) const;
-    QUniformValue inverseViewportMatrix(const QMatrix4x4 &model) const;
-    QUniformValue time(const QMatrix4x4 &model) const;
-    QUniformValue eyePosition(const QMatrix4x4 &model) const;
-
-    void setUniformValue(ShaderParameterPack &uniformPack, int nameId, const QVariant &value) const;
+    UniformValue modelMatrix(const QMatrix4x4& model) const;
+    UniformValue viewMatrix(const QMatrix4x4&) const;
+    UniformValue projectionMatrix(const QMatrix4x4 &) const;
+    UniformValue modelViewMatrix(const QMatrix4x4 &model) const;
+    UniformValue viewProjectionMatrix(const QMatrix4x4 &model) const;
+    UniformValue modelViewProjectionMatrix(const QMatrix4x4 &model) const;
+    UniformValue inverseModelMatrix(const QMatrix4x4 &model) const;
+    UniformValue inverseViewMatrix(const QMatrix4x4 &) const;
+    UniformValue inverseProjectionMatrix(const QMatrix4x4 &) const;
+    UniformValue inverseModelViewMatrix(const QMatrix4x4 &model) const;
+    UniformValue inverseViewProjectionMatrix(const QMatrix4x4 &model) const;
+    UniformValue inverseModelViewProjectionMatrix(const QMatrix4x4 &model) const;
+    UniformValue modelNormalMatrix(const QMatrix4x4 &model) const;
+    UniformValue modelViewNormalMatrix(const QMatrix4x4 &model) const;
+    UniformValue viewportMatrix(const QMatrix4x4 &model) const;
+    UniformValue inverseViewportMatrix(const QMatrix4x4 &model) const;
+    UniformValue time(const QMatrix4x4 &model) const;
+    UniformValue eyePosition(const QMatrix4x4 &model) const;
+
+    void setUniformValue(ShaderParameterPack &uniformPack, int nameId, const UniformValue &value) const;
     void setStandardUniformValue(ShaderParameterPack &uniformPack, int glslNameId, int nameId, const QMatrix4x4 &worldTransform) const;
     void setUniformBlockValue(ShaderParameterPack &uniformPack,
                               Shader *shader,
                               const ShaderUniformBlock &block,
-                              const QVariant &value) const;
+                              const UniformValue &value) const;
     void setShaderStorageValue(ShaderParameterPack &uniformPack,
                                Shader *shader,
                                const ShaderStorageBlock &block,
-                               const QVariant &value) const;
+                               const UniformValue &value) const;
     void setDefaultUniformBlockShaderDataValue(ShaderParameterPack &uniformPack,
                                                Shader *shader,
                                                ShaderData *shaderData,
diff --git a/src/render/graphicshelpers/graphicscontext.cpp b/src/render/graphicshelpers/graphicscontext.cpp
index 021637c24..9731e7c5e 100644
--- a/src/render/graphicshelpers/graphicscontext.cpp
+++ b/src/render/graphicshelpers/graphicscontext.cpp
@@ -1084,12 +1084,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;
             }
         }
     }
@@ -1145,8 +1145,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]);
     }
 }
 
@@ -1176,6 +1175,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)
 {
diff --git a/src/render/graphicshelpers/graphicscontext_p.h b/src/render/graphicshelpers/graphicscontext_p.h
index 7f380e250..b8b777434 100644
--- a/src/render/graphicshelpers/graphicscontext_p.h
+++ b/src/render/graphicshelpers/graphicscontext_p.h
@@ -317,6 +317,8 @@ 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
     {
diff --git a/src/render/jobs/renderviewjobutils.cpp b/src/render/jobs/renderviewjobutils.cpp
index e5b763fcf..798828bd3 100644
--- a/src/render/jobs/renderviewjobutils.cpp
+++ b/src/render/jobs/renderviewjobutils.cpp
@@ -391,7 +391,7 @@ void addParametersForIds(ParameterInfoList *params, ParameterManager *manager,
         Parameter *param = manager->lookupResource(paramId);
         ParameterInfoList::iterator it = std::lower_bound(params->begin(), params->end(), param->nameId());
         if (it == params->end() || it->nameId != param->nameId())
-            params->insert(it, ParameterInfo(param->nameId(), param->value()));
+            params->insert(it, ParameterInfo(param->nameId(), param->uniformValue()));
     }
 }
 
@@ -491,7 +491,7 @@ void UniformBlockValueBuilder::buildActiveUniformNameValueMapStructHelper(Shader
     }
 }
 
-ParameterInfo::ParameterInfo(const int nameId, const QVariant &value)
+ParameterInfo::ParameterInfo(const int nameId, const UniformValue &value)
     : nameId(nameId)
     , value(value)
 {}
diff --git a/src/render/jobs/renderviewjobutils_p.h b/src/render/jobs/renderviewjobutils_p.h
index 7f70690d7..df4753980 100644
--- a/src/render/jobs/renderviewjobutils_p.h
+++ b/src/render/jobs/renderviewjobutils_p.h
@@ -55,6 +55,7 @@
 #include <Qt3DCore/qnodeid.h>
 #include <QtCore/qhash.h>
 #include <QtCore/qvariant.h>
+#include <Qt3DRender/private/uniform_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -106,10 +107,10 @@ Q_AUTOTEST_EXPORT inline T variant_value(const QVariant &v)
 
 struct ParameterInfo
 {
-    explicit ParameterInfo(const int nameId = -1, const QVariant &value = QVariant());
+    explicit ParameterInfo(const int nameId = -1, const UniformValue &value = UniformValue());
 
     int nameId;
-    QVariant value;
+    UniformValue value;
 
     bool operator<(const int otherNameId) const Q_DECL_NOEXCEPT;
     bool operator<(const ParameterInfo &other) const Q_DECL_NOEXCEPT;