Cleanup setShaderAndUniforms

Similar to what was done for the rhi plugin

Change-Id: I266a3992e21faa2633036c809e884d91d4d892da
Reviewed-by: Mike Krus <mike.krus@kdab.com>

8 files changed, 144 insertions, 79 deletions

diff --git a/src/plugins/renderers/opengl/jobs/renderviewjobutils.cpp b/src/plugins/renderers/opengl/jobs/renderviewjobutils.cpp
index d4835054b..8774ac368 100644
--- a/src/plugins/renderers/opengl/jobs/renderviewjobutils.cpp
+++ b/src/plugins/renderers/opengl/jobs/renderviewjobutils.cpp
@@ -473,7 +473,10 @@ UniformBlockValueBuilder::~UniformBlockValueBuilder()
 {
 }
 
-void UniformBlockValueBuilder::buildActiveUniformNameValueMapHelper(ShaderData *currentShaderData, const QString &blockName, const QString &qmlPropertyName, const QVariant &value)
+void UniformBlockValueBuilder::buildActiveUniformNameValueMapHelper(const ShaderData *currentShaderData,
+                                                                    const QString &blockName,
+                                                                    const QString &qmlPropertyName,
+                                                                    const QVariant &value)
 {
     // In the end, values are either scalar or a scalar array
     // Composed elements (structs, structs array) are simplified into simple scalars
@@ -534,7 +537,9 @@ void UniformBlockValueBuilder::buildActiveUniformNameValueMapHelper(ShaderData *
     }
 }
 
-void UniformBlockValueBuilder::buildActiveUniformNameValueMapStructHelper(ShaderData *rShaderData, const QString &blockName, const QString &qmlPropertyName)
+void UniformBlockValueBuilder::buildActiveUniformNameValueMapStructHelper(const ShaderData *rShaderData,
+                                                                          const QString &blockName,
+                                                                          const QString &qmlPropertyName)
 {
     const QHash<QString, ShaderData::PropertyValue> &properties = rShaderData->properties();
     auto it = properties.begin();
diff --git a/src/plugins/renderers/opengl/jobs/renderviewjobutils_p.h b/src/plugins/renderers/opengl/jobs/renderviewjobutils_p.h
index 5b1413108..f9fab6185 100644
--- a/src/plugins/renderers/opengl/jobs/renderviewjobutils_p.h
+++ b/src/plugins/renderers/opengl/jobs/renderviewjobutils_p.h
@@ -166,11 +166,11 @@ struct Q_AUTOTEST_EXPORT UniformBlockValueBuilder
 
     QT3D_ALIGNED_MALLOC_AND_FREE()
 
-    void buildActiveUniformNameValueMapHelper(ShaderData *currentShaderData,
+    void buildActiveUniformNameValueMapHelper(const ShaderData *currentShaderData,
                                               const QString &blockName,
                                               const QString &qmlPropertyName,
                                               const QVariant &value);
-    void buildActiveUniformNameValueMapStructHelper(ShaderData *rShaderData,
+    void buildActiveUniformNameValueMapStructHelper(const ShaderData *rShaderData,
                                                     const QString &blockName,
                                                     const QString &qmlPropertyName = QString());
 
diff --git a/src/plugins/renderers/opengl/renderer/glshader.cpp b/src/plugins/renderers/opengl/renderer/glshader.cpp
index 2bc861928..b4e198863 100644
--- a/src/plugins/renderers/opengl/renderer/glshader.cpp
+++ b/src/plugins/renderers/opengl/renderer/glshader.cpp
@@ -84,11 +84,19 @@ QVector<int> getLightUniformNameIds()
     return names;
 }
 
+template<typename Vector>
+bool fastContains(const Vector &v, int value)
+{
+    return std::binary_search(v.cbegin(), v.cend(), value);
+}
+
 }
 
 GLShader::GLShader()
     : m_isLoaded(false)
     , m_graphicsContext(nullptr)
+    , m_parameterPackSize(0)
+    , m_hasActiveVariables(false)
 {
     m_shaderCode.resize(static_cast<int>(QShaderProgram::Compute) + 1);
 }
@@ -141,7 +149,7 @@ QHash<QString, ShaderUniform> GLShader::activeUniformsForUniformBlock(int blockI
     return m_uniformBlockIndexToShaderUniforms.value(blockIndex);
 }
 
-ShaderUniformBlock GLShader::uniformBlockForBlockIndex(int blockIndex)
+ShaderUniformBlock GLShader::uniformBlockForBlockIndex(int blockIndex) const noexcept
 {
     for (int i = 0, m = m_uniformBlocks.size(); i < m; ++i) {
         if (m_uniformBlocks[i].m_index == blockIndex) {
@@ -151,7 +159,7 @@ ShaderUniformBlock GLShader::uniformBlockForBlockIndex(int blockIndex)
     return ShaderUniformBlock();
 }
 
-ShaderUniformBlock GLShader::uniformBlockForBlockNameId(int blockNameId)
+ShaderUniformBlock GLShader::uniformBlockForBlockNameId(int blockNameId) const noexcept
 {
     for (int i = 0, m = m_uniformBlocks.size(); i < m; ++i) {
         if (m_uniformBlocks[i].m_nameId == blockNameId) {
@@ -161,7 +169,7 @@ ShaderUniformBlock GLShader::uniformBlockForBlockNameId(int blockNameId)
     return ShaderUniformBlock();
 }
 
-ShaderUniformBlock GLShader::uniformBlockForBlockName(const QString &blockName)
+ShaderUniformBlock GLShader::uniformBlockForBlockName(const QString &blockName) const noexcept
 {
     for (int i = 0, m = m_uniformBlocks.size(); i < m; ++i) {
         if (m_uniformBlocks[i].m_name == blockName) {
@@ -171,7 +179,7 @@ ShaderUniformBlock GLShader::uniformBlockForBlockName(const QString &blockName)
     return ShaderUniformBlock();
 }
 
-ShaderStorageBlock GLShader::storageBlockForBlockIndex(int blockIndex)
+ShaderStorageBlock GLShader::storageBlockForBlockIndex(int blockIndex) const noexcept
 {
     for (int i = 0, m = m_shaderStorageBlockNames.size(); i < m; ++i) {
         if (m_shaderStorageBlocks[i].m_index == blockIndex)
@@ -180,7 +188,7 @@ ShaderStorageBlock GLShader::storageBlockForBlockIndex(int blockIndex)
     return ShaderStorageBlock();
 }
 
-ShaderStorageBlock GLShader::storageBlockForBlockNameId(int blockNameId)
+ShaderStorageBlock GLShader::storageBlockForBlockNameId(int blockNameId) const noexcept
 {
     for (int i = 0, m = m_shaderStorageBlockNames.size(); i < m; ++i) {
         if (m_shaderStorageBlocks[i].m_nameId == blockNameId)
@@ -189,7 +197,7 @@ ShaderStorageBlock GLShader::storageBlockForBlockNameId(int blockNameId)
     return ShaderStorageBlock();
 }
 
-ShaderStorageBlock GLShader::storageBlockForBlockName(const QString &blockName)
+ShaderStorageBlock GLShader::storageBlockForBlockName(const QString &blockName) const noexcept
 {
     for (int i = 0, m = m_shaderStorageBlockNames.size(); i < m; ++i) {
         if (m_shaderStorageBlocks[i].m_name == blockName)
@@ -198,6 +206,22 @@ ShaderStorageBlock GLShader::storageBlockForBlockName(const QString &blockName)
     return ShaderStorageBlock();
 }
 
+GLShader::ParameterKind GLShader::categorizeVariable(int nameId) const noexcept
+{
+    if (fastContains(m_uniformsNamesIds, nameId))
+        return ParameterKind::Uniform;
+    if (fastContains(m_uniformBlockNamesIds, nameId))
+        return ParameterKind::UBO;
+    if (fastContains(m_shaderStorageBlockNamesIds, nameId))
+        return ParameterKind::SSBO;
+    return ParameterKind::Struct;
+}
+
+bool GLShader::hasUniform(int nameId) const noexcept
+{
+    return m_uniformsNamesIds.contains(nameId);
+}
+
 void GLShader::prepareUniforms(ShaderParameterPack &pack)
 {
     const PackUniformHash &values = pack.uniforms();
@@ -223,7 +247,6 @@ void GLShader::setFragOutputs(const QHash<QString, int> &fragOutputs)
         QMutexLocker lock(&m_mutex);
         m_fragOutputs = fragOutputs;
     }
-//    updateDNA();
 }
 
 const QHash<QString, int> GLShader::fragOutputs() const
@@ -288,6 +311,14 @@ void GLShader::initializeUniforms(const QVector<ShaderUniform> &uniformsDescript
         }
     }
     m_uniformBlockIndexToShaderUniforms.insert(-1, activeUniformsInDefaultBlock);
+
+    m_parameterPackSize += m_standardUniformNamesIds.size() + m_lightUniformsNamesIds.size() + m_uniformsNamesIds.size();
+    m_hasActiveVariables |= (m_parameterPackSize > 0);
+
+    // Sort by ascending order to make contains check faster
+    std::sort(m_uniformsNamesIds.begin(), m_uniformsNamesIds.end());
+    std::sort(m_lightUniformsNamesIds.begin(), m_lightUniformsNamesIds.end());
+    std::sort(m_standardUniformNamesIds.begin(), m_standardUniformNamesIds.end());
 }
 
 void GLShader::initializeAttributes(const QVector<ShaderAttribute> &attributesDescription)
@@ -301,6 +332,7 @@ void GLShader::initializeAttributes(const QVector<ShaderAttribute> &attributesDe
         m_attributeNamesIds[i] = m_attributes[i].m_nameId;
         qCDebug(Shaders) << "Active Attribute " << attributesDescription[i].m_name;
     }
+    m_hasActiveVariables |= (m_attributeNamesIds.size() > 0);
 }
 
 void GLShader::initializeUniformBlocks(const QVector<ShaderUniformBlock> &uniformBlockDescription)
@@ -336,6 +368,12 @@ void GLShader::initializeUniformBlocks(const QVector<ShaderUniformBlock> &unifor
         }
         m_uniformBlockIndexToShaderUniforms.insert(uniformBlockDescription[i].m_index, activeUniformsInBlock);
     }
+
+    m_parameterPackSize += m_uniformsNamesIds.size();
+    m_hasActiveVariables |= (m_parameterPackSize > 0);
+
+    // Sort by ascending order to make contains check faster
+    std::sort(m_uniformBlockNamesIds.begin(), m_uniformBlockNamesIds.end());
 }
 
 void GLShader::initializeShaderStorageBlocks(const QVector<ShaderStorageBlock> &shaderStorageBlockDescription)
@@ -350,6 +388,12 @@ void GLShader::initializeShaderStorageBlocks(const QVector<ShaderStorageBlock> &
         m_shaderStorageBlocks[i].m_nameId =m_shaderStorageBlockNamesIds[i];
         qCDebug(Shaders) << "Initializing Shader Storage Block {" << m_shaderStorageBlockNames[i] << "}";
     }
+
+    m_parameterPackSize += m_shaderStorageBlockNamesIds.size();
+    m_hasActiveVariables |= (m_parameterPackSize > 0);
+
+    // Sort by ascending order to make contains check faster
+    std::sort(m_shaderStorageBlockNamesIds.begin(), m_shaderStorageBlockNamesIds.end());
 }
 
 } // OpenGL
diff --git a/src/plugins/renderers/opengl/renderer/glshader_p.h b/src/plugins/renderers/opengl/renderer/glshader_p.h
index 07d40c724..28b64b058 100644
--- a/src/plugins/renderers/opengl/renderer/glshader_p.h
+++ b/src/plugins/renderers/opengl/renderer/glshader_p.h
@@ -106,13 +106,25 @@ public:
 
     QHash<QString, ShaderUniform> activeUniformsForUniformBlock(int blockIndex) const;
 
-    ShaderUniformBlock uniformBlockForBlockIndex(int blockNameId);
-    ShaderUniformBlock uniformBlockForBlockNameId(int blockIndex);
-    ShaderUniformBlock uniformBlockForBlockName(const QString &blockName);
-
-    ShaderStorageBlock storageBlockForBlockIndex(int blockIndex);
-    ShaderStorageBlock storageBlockForBlockNameId(int blockNameId);
-    ShaderStorageBlock storageBlockForBlockName(const QString &blockName);
+    ShaderUniformBlock uniformBlockForBlockIndex(int blockNameId) const noexcept;
+    ShaderUniformBlock uniformBlockForBlockNameId(int blockIndex) const noexcept;
+    ShaderUniformBlock uniformBlockForBlockName(const QString &blockName) const noexcept;
+
+    ShaderStorageBlock storageBlockForBlockIndex(int blockIndex) const noexcept;
+    ShaderStorageBlock storageBlockForBlockNameId(int blockNameId) const noexcept;
+    ShaderStorageBlock storageBlockForBlockName(const QString &blockName) const noexcept;
+
+    enum ParameterKind {
+        Uniform,
+        UBO,
+        SSBO,
+        Struct
+    };
+    ParameterKind categorizeVariable(int nameId) const noexcept;
+
+    bool hasUniform(int nameId) const noexcept;
+    inline bool hasActiveVariables() const noexcept { return m_hasActiveVariables; }
+    inline int parameterPackSize() const noexcept { return m_parameterPackSize; }
 
     QOpenGLShaderProgram *shaderProgram() { return &m_shader; }
 
@@ -146,6 +158,9 @@ private:
     QHash<QString, int> m_fragOutputs;
     QVector<QByteArray> m_shaderCode;
 
+    int m_parameterPackSize;
+    int m_hasActiveVariables;
+
     // Private so that only GraphicContext can call it
     void initializeUniforms(const QVector<ShaderUniform> &uniformsDescription);
     void initializeAttributes(const QVector<ShaderAttribute> &attributesDescription);
diff --git a/src/plugins/renderers/opengl/renderer/renderview.cpp b/src/plugins/renderers/opengl/renderer/renderview.cpp
index 5757c7851..048ceef7b 100644
--- a/src/plugins/renderers/opengl/renderer/renderview.cpp
+++ b/src/plugins/renderers/opengl/renderer/renderview.cpp
@@ -148,9 +148,10 @@ static Matrix4x4 getProjectionMatrix(const CameraLens *lens)
 }
 
 UniformValue RenderView::standardUniformValue(RenderView::StandardUniform standardUniformType,
-                                              Entity *entity,
-                                              const Matrix4x4 &model) const
+                                              const Entity *entity) const
 {
+    const Matrix4x4 &model = *(entity->worldTransform());
+
     switch (standardUniformType) {
     case ModelMatrix:
         return UniformValue(model);
@@ -925,21 +926,16 @@ void RenderView::setUniformValue(ShaderParameterPack &uniformPack, int nameId, c
 }
 
 void RenderView::setStandardUniformValue(ShaderParameterPack &uniformPack,
-                                         int glslNameId,
                                          int nameId,
-                                         Entity *entity,
-                                         const Matrix4x4 &worldTransform) const
+                                         const Entity *entity) const
 {
-    uniformPack.setUniform(glslNameId, standardUniformValue(ms_standardUniformSetters[nameId], entity, worldTransform));
+    uniformPack.setUniform(nameId, standardUniformValue(ms_standardUniformSetters[nameId], entity));
 }
 
 void RenderView::setUniformBlockValue(ShaderParameterPack &uniformPack,
-                                      GLShader *shader,
                                       const ShaderUniformBlock &block,
                                       const UniformValue &value) const
 {
-    Q_UNUSED(shader)
-
     if (value.valueType() == UniformValue::NodeId) {
 
         Buffer *buffer = nullptr;
@@ -955,11 +951,9 @@ void RenderView::setUniformBlockValue(ShaderParameterPack &uniformPack,
 }
 
 void RenderView::setShaderStorageValue(ShaderParameterPack &uniformPack,
-                                       GLShader *shader,
                                        const ShaderStorageBlock &block,
                                        const UniformValue &value) const
 {
-    Q_UNUSED(shader)
     if (value.valueType() == UniformValue::NodeId) {
         Buffer *buffer = nullptr;
         if ((buffer = m_manager->bufferManager()->lookupResource(*value.constData<Qt3DCore::QNodeId>())) != nullptr) {
@@ -973,7 +967,10 @@ void RenderView::setShaderStorageValue(ShaderParameterPack &uniformPack,
     }
 }
 
-void RenderView::setDefaultUniformBlockShaderDataValue(ShaderParameterPack &uniformPack, GLShader *shader, ShaderData *shaderData, const QString &structName) const
+void RenderView::setDefaultUniformBlockShaderDataValue(ShaderParameterPack &uniformPack,
+                                                       const GLShader *shader,
+                                                       const ShaderData *shaderData,
+                                                       const QString &structName) const
 {
     UniformBlockValueBuilder *builder = m_localData.localData();
     builder->activeUniformNamesToValue.clear();
@@ -997,6 +994,42 @@ void RenderView::setDefaultUniformBlockShaderDataValue(ShaderParameterPack &unif
     }
 }
 
+void RenderView::applyParameter(const Parameter *param,
+                                RenderCommand *command,
+                                const GLShader *shader) const noexcept
+{
+    const int nameId = param->nameId();
+    const UniformValue &uniformValue = param->uniformValue();
+    const GLShader::ParameterKind kind = shader->categorizeVariable(nameId);
+
+    switch (kind) {
+    case GLShader::Uniform: {
+        setUniformValue(command->m_parameterPack, nameId, uniformValue);
+        break;
+    }
+    case GLShader::UBO: {
+        setUniformBlockValue(command->m_parameterPack, shader->uniformBlockForBlockNameId(nameId), uniformValue);
+        break;
+    }
+    case GLShader::SSBO: {
+        setShaderStorageValue(command->m_parameterPack, shader->storageBlockForBlockNameId(nameId), uniformValue);
+        break;
+    }
+    case GLShader::Struct: {
+        ShaderData *shaderData = nullptr;
+        if (uniformValue.valueType() == UniformValue::NodeId &&
+                (shaderData = m_manager->shaderDataManager()->lookupResource(*uniformValue.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(nameId));
+        }
+        break;
+    }
+    default:
+        break;
+    }
+}
+
+
 void RenderView::setShaderAndUniforms(RenderCommand *command,
                                       ParameterInfoList &parameters,
                                       Entity *entity,
@@ -1019,12 +1052,6 @@ void RenderView::setShaderAndUniforms(RenderCommand *command,
         // Builds the QUniformPack, sets shader standard uniforms and store attributes name / glname bindings
         // If a parameter is defined and not found in the bindings it is assumed to be a binding of Uniform type with the glsl name
         // equals to the parameter name
-        const QVector<int> &uniformNamesIds = shader->uniformsNamesIds();
-        const QVector<int> &standardUniformNamesIds = shader->standardUniformNameIds();
-        const QVector<int> &lightUniformNamesIds = shader->lightUniformsNamesIds();
-        const QVector<int> &uniformBlockNamesIds = shader->uniformBlockNamesIds();
-        const QVector<int> &shaderStorageBlockNamesIds = shader->storageBlockNamesIds();
-        const QVector<int> &attributeNamesIds = shader->attributeNamesIds();
 
         // Set fragData Name and index
         // Later on we might want to relink the shader if attachments have changed
@@ -1042,56 +1069,32 @@ void RenderView::setShaderAndUniforms(RenderCommand *command,
         }
 
         // Set default attributes
-        command->m_activeAttributes = attributeNamesIds;
+        command->m_activeAttributes = shader->attributeNamesIds();
 
         // At this point we know whether the command is a valid draw command or not
         // We still need to process the uniforms as the command could be a compute command
         command->m_isValid = !command->m_activeAttributes.empty();
 
-        if (!uniformNamesIds.isEmpty() || !standardUniformNamesIds.isEmpty() ||
-            !attributeNamesIds.isEmpty() || !lightUniformNamesIds.isEmpty() ||
-            !shaderStorageBlockNamesIds.isEmpty() || command->m_isValid) {
-
-            // Set default standard uniforms without bindings
-            const Matrix4x4 worldTransform = *(entity->worldTransform());
+        if (shader->hasActiveVariables()) {
 
             // Reserve amount of uniforms we are going to need
-            command->m_parameterPack.reserve(uniformNamesIds.size() + standardUniformNamesIds.size() + lightUniformNamesIds.size() + uniformBlockNamesIds.size() + shaderStorageBlockNamesIds.size());
+            command->m_parameterPack.reserve(shader->parameterPackSize());
 
+            const QVector<int> &standardUniformNamesIds = shader->standardUniformNameIds();
             for (const int uniformNameId : standardUniformNamesIds)
-                setStandardUniformValue(command->m_parameterPack, uniformNameId, uniformNameId, entity, worldTransform);
-
-            // Parameters remaining could be
-            // -> uniform scalar / vector
-            // -> uniform struct / arrays
-            // -> uniform block / array (4.3)
-            // -> ssbo block / array (4.3)
+                setStandardUniformValue(command->m_parameterPack, uniformNameId, entity);
 
             ParameterInfoList::const_iterator it = parameters.cbegin();
             const ParameterInfoList::const_iterator parametersEnd = parameters.cend();
 
             while (it != parametersEnd) {
-                Parameter *param = m_manager->data<Parameter, ParameterManager>(it->handle);
-                const UniformValue &uniformValue = param->uniformValue();
-                if (uniformNamesIds.contains(it->nameId)) { // Parameter is a regular uniform
-                    setUniformValue(command->m_parameterPack, it->nameId, uniformValue);
-                } else if (uniformBlockNamesIds.indexOf(it->nameId) != -1) { // Parameter is a uniform block
-                    setUniformBlockValue(command->m_parameterPack, shader, shader->uniformBlockForBlockNameId(it->nameId), uniformValue);
-                } else if (shaderStorageBlockNamesIds.indexOf(it->nameId) != -1) { // Parameters is a SSBO
-                    setShaderStorageValue(command->m_parameterPack, shader, shader->storageBlockForBlockNameId(it->nameId), uniformValue);
-                } else { // Parameter is a struct
-                    ShaderData *shaderData = nullptr;
-                    if (uniformValue.valueType() == UniformValue::NodeId &&
-                            (shaderData = m_manager->shaderDataManager()->lookupResource(*uniformValue.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));
-                    }
-                    // Otherwise: param unused by current shader
-                }
+                const Parameter *param = m_manager->data<Parameter, ParameterManager>(it->handle);
+                applyParameter(param, command, shader);
                 ++it;
             }
 
             // Lights
+            const QVector<int> &lightUniformNamesIds = shader->lightUniformsNamesIds();
             if (!lightUniformNamesIds.empty()) {
                 int lightIdx = 0;
                 for (const LightSource &lightSource : activeLightSources) {
diff --git a/src/plugins/renderers/opengl/renderer/renderview_p.h b/src/plugins/renderers/opengl/renderer/renderview_p.h
index c9e69d507..85dafe3fd 100644
--- a/src/plugins/renderers/opengl/renderer/renderview_p.h
+++ b/src/plugins/renderers/opengl/renderer/renderview_p.h
@@ -371,27 +371,25 @@ private:
     static StandardUniformsNameToTypeHash initializeStandardUniformSetters();
 
     UniformValue standardUniformValue(StandardUniform standardUniformType,
-                                      Entity *entity,
-                                      const Matrix4x4 &model) const;
+                                      const Entity *entity) const;
 
     void setUniformValue(ShaderParameterPack &uniformPack, int nameId, const UniformValue &value) const;
     void setStandardUniformValue(ShaderParameterPack &uniformPack,
-                                 int glslNameId,
                                  int nameId,
-                                 Entity *entity,
-                                 const Matrix4x4 &worldTransform) const;
+                                 const Entity *entity) const;
     void setUniformBlockValue(ShaderParameterPack &uniformPack,
-                              GLShader *shader,
                               const ShaderUniformBlock &block,
                               const UniformValue &value) const;
     void setShaderStorageValue(ShaderParameterPack &uniformPack,
-                               GLShader *shader,
                                const ShaderStorageBlock &block,
                                const UniformValue &value) const;
     void setDefaultUniformBlockShaderDataValue(ShaderParameterPack &uniformPack,
-                                               GLShader *shader,
-                                               ShaderData *shaderData,
+                                               const GLShader *shader,
+                                               const ShaderData *shaderData,
                                                const QString &structName) const;
+    void applyParameter(const Parameter *param,
+                        RenderCommand *command,
+                        const GLShader *shader) const noexcept;
 };
 
 } // namespace OpenGL
diff --git a/src/render/materialsystem/shaderdata.cpp b/src/render/materialsystem/shaderdata.cpp
index 67c8f35f7..97db303c2 100644
--- a/src/render/materialsystem/shaderdata.cpp
+++ b/src/render/materialsystem/shaderdata.cpp
@@ -162,7 +162,7 @@ ShaderData *ShaderData::lookupResource(QNodeId id)
 }
 
 // RenderCommand updater jobs
-QVariant ShaderData::getTransformedProperty(const QString &name, const Matrix4x4 &viewMatrix)
+QVariant ShaderData::getTransformedProperty(const QString &name, const Matrix4x4 &viewMatrix) const
 {
     // Note protecting m_worldMatrix at this point as we assume all world updates
     // have been performed when reaching this point
diff --git a/src/render/materialsystem/shaderdata_p.h b/src/render/materialsystem/shaderdata_p.h
index 5c6352eba..080d2c85e 100644
--- a/src/render/materialsystem/shaderdata_p.h
+++ b/src/render/materialsystem/shaderdata_p.h
@@ -89,7 +89,7 @@ public:
     // Called by FramePreparationJob
     void updateWorldTransform(const Matrix4x4 &worldMatrix);
 
-    QVariant getTransformedProperty(const QString &name, const Matrix4x4 &viewMatrix);
+    QVariant getTransformedProperty(const QString &name, const Matrix4x4 &viewMatrix) const;
 
     // Unit tests purposes only
     TransformType propertyTransformType(const QString &name) const;