Automatic uniform binding

If the shader contains a uniform with a standard uniform name,
it will automatically be set. If a custom name is used within a shader for a
standard uniform variable, the user can add a ParameterMapper with
parameterName set to the Qt3D standardUniform name and shaderVariableName to
the custom name.

For user specified uniform parameters, if the parameter name is the same as
the shader uniform name, the binding is done automatically. Otherwise, a
ParameterMapper can be used.

At the moment automatic binding for Attributes still has to be sorted out as
default attribute names are dependent on a given MeshData.

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

6 files changed, 102 insertions, 107 deletions

diff --git a/src/render/backend/renderer.cpp b/src/render/backend/renderer.cpp
index 0ced2af28..6e0adf798 100644
--- a/src/render/backend/renderer.cpp
+++ b/src/render/backend/renderer.cpp
@@ -175,19 +175,6 @@ void Renderer::buildDefaultTechnique()
     basicPass->addBinding(new ParameterMapper(QStringLiteral("position"), QStringLiteral("vertexPosition"), ParameterMapper::Attribute));
     basicPass->addBinding(new ParameterMapper(QStringLiteral("normal"), QStringLiteral("vertexNormal"), ParameterMapper::Attribute));
 
-    // matrix uniforms from standard
-    Parameter* mvMat = new Parameter(m_defaultTechnique, QStringLiteral("modelView"), Parameter::ModelView);
-    m_defaultTechnique->addParameter(mvMat);
-    basicPass->addBinding(new ParameterMapper(QStringLiteral("modelView"), QStringLiteral("modelViewMatrix"), ParameterMapper::StandardUniform));
-
-    Parameter* nMat = new Parameter(m_defaultTechnique, QStringLiteral("normalMat"), Parameter::ModelViewNormal);
-    m_defaultTechnique->addParameter(nMat);
-    basicPass->addBinding(new ParameterMapper(QStringLiteral("normalMat"), QStringLiteral("normalMatrix"), ParameterMapper::StandardUniform));
-
-    Parameter* mvpMat = new Parameter(m_defaultTechnique, QStringLiteral("mvp"), Parameter::ModelViewProjection);
-    m_defaultTechnique->addParameter(mvpMat);
-    basicPass->addBinding(new ParameterMapper(QStringLiteral("mvp"), QStringLiteral("mvp"), ParameterMapper::StandardUniform));
-
     // diffuse lighting uniforms
     Parameter* lightPos = new Parameter(m_defaultTechnique, QStringLiteral("lightPos"), QVector4D(10.0f, 10.0f, 0.0f, 1.0f));
     m_defaultTechnique->addParameter(lightPos);
diff --git a/src/render/backend/renderview.cpp b/src/render/backend/renderview.cpp
index 9cd1d6a52..59a8475bc 100644
--- a/src/render/backend/renderview.cpp
+++ b/src/render/backend/renderview.cpp
@@ -85,27 +85,41 @@ namespace Qt3D {
 namespace Render {
 
 RenderView::standardUniformsPFuncsHash RenderView::m_standardUniformSetters = RenderView::initializeStandardUniformSetters();
+QStringList RenderView::m_standardAttributesNames = RenderView::initializeStandardAttributeNames();
 
 RenderView::standardUniformsPFuncsHash RenderView::initializeStandardUniformSetters()
 {
     RenderView::standardUniformsPFuncsHash setters;
 
-    setters[Parameter::ModelMatrix] = &RenderView::modelMatrix;
-    setters[Parameter::ViewMatrix] = &RenderView::viewMatrix;
-    setters[Parameter::ProjectionMatrix] = &RenderView::projectionMatrix;
-    setters[Parameter::ModelView] = &RenderView::modelViewMatrix;
-    setters[Parameter::ModelViewProjection] = &RenderView::modelViewProjectionMatrix;
-    setters[Parameter::ModelInverse] = &RenderView::inverseModelMatrix;
-    setters[Parameter::ViewInverse] = &RenderView::inverseViewMatrix;
-    setters[Parameter::ProjectionInverse] = &RenderView::inverseProjectionMatrix;
-    setters[Parameter::ModelViewInverse] = &RenderView::inverseModelViewMatrix;
-    setters[Parameter::ModelViewProjectionInverse] = &RenderView::inverseModelViewProjectionMatrix;
-    setters[Parameter::ModelNormal] = &RenderView::modelNormalMatrix;
-    setters[Parameter::ModelViewNormal] = &RenderView::modelViewNormalMatrix;
+    setters[QStringLiteral("modelMatrix")] = &RenderView::modelMatrix;
+    setters[QStringLiteral("viewMatrix")] = &RenderView::viewMatrix;
+    setters[QStringLiteral("projectionMatrix")] = &RenderView::projectionMatrix;
+    setters[QStringLiteral("modelView")] = &RenderView::modelViewMatrix;
+    setters[QStringLiteral("modelViewProjection")] = &RenderView::modelViewProjectionMatrix;
+    setters[QStringLiteral("mvp")] = &RenderView::modelViewProjectionMatrix;
+    setters[QStringLiteral("inverseModelMatrix")] = &RenderView::inverseModelMatrix;
+    setters[QStringLiteral("inverViewMatrix")] = &RenderView::inverseViewMatrix;
+    setters[QStringLiteral("inverseProjectionMatrix")] = &RenderView::inverseProjectionMatrix;
+    setters[QStringLiteral("inverseModelView")] = &RenderView::inverseModelViewMatrix;
+    setters[QStringLiteral("inverseModelViewProjection")] = &RenderView::inverseModelViewProjectionMatrix;
+    setters[QStringLiteral("modelNormalMatrix")] = &RenderView::modelNormalMatrix;
+    setters[QStringLiteral("modelViewNormal")] = &RenderView::modelViewNormalMatrix;
 
     return setters;
 }
 
+QStringList RenderView::initializeStandardAttributeNames()
+{
+    QStringList attributesNames;
+
+    attributesNames << QStringLiteral("vertexPosition");
+    attributesNames << QStringLiteral("vertexNormal");
+    attributesNames << QStringLiteral("vertexColor");
+    attributesNames << QStringLiteral("vertexTextCoord");
+
+    return attributesNames;
+}
+
 QUniformValue *RenderView::modelMatrix(RenderCamera *, const QMatrix4x4 &model) const
 {
     SpecifiedUniform<QMatrix4x4> *t = m_allocator->allocate<SpecifiedUniform<QMatrix4x4> >();
@@ -507,42 +521,58 @@ void RenderView::setShaderAndUniforms(RenderCommand *command, RenderRenderPass *
 
         if (!uniformNames.isEmpty() && !attributeNames.isEmpty()) {
 
+            // Set default standard uniforms without bindings
+            Q_FOREACH (const QString &uniformName, uniformNames) {
+                if (m_standardUniformSetters.contains(uniformName))
+                    command->m_uniforms.setUniform(uniformName,
+                                                   (this->*m_standardUniformSetters[uniformName])(m_renderCamera, command->m_worldMatrix));
+            }
+
+            // Set default attributes
+            Q_FOREACH (const QString &attributeName, attributeNames) {
+                if (m_standardAttributesNames.contains(attributeName))
+                    command->m_parameterAttributeToShaderNames[attributeName] = attributeName;
+            }
+
+            // Set uniforms and attributes explicitly binded
             Q_FOREACH (ParameterMapper *binding, rPass->bindings()) {
                 if (!parameters.contains(binding->parameterName())) {
-                    if (binding->bindingType() == ParameterMapper::Attribute)
+                    if (binding->bindingType() == ParameterMapper::Attribute
+                            && attributeNames.contains(binding->shaderVariableName()))
                         command->m_parameterAttributeToShaderNames[binding->parameterName()] = binding->shaderVariableName();
+                    else if (binding->bindingType() == ParameterMapper::StandardUniform
+                             && uniformNames.contains(binding->shaderVariableName())
+                             && m_standardUniformSetters.contains(binding->parameterName()))
+                        command->m_uniforms.setUniform(binding->shaderVariableName(),
+                                                       (this->*m_standardUniformSetters[binding->parameterName()])(m_renderCamera, command->m_worldMatrix));
                     else
                         qCWarning(Render::Backend) << Q_FUNC_INFO << "Trying to bind a Parameter that hasn't been defined " << binding->parameterName();
                 }
                 else {
-                    if (binding->bindingType() == ParameterMapper::Uniform) {
-                        QVariant value = parameters.take(binding->parameterName());
-                        Texture *tex = Q_NULLPTR;
-                        if (static_cast<QMetaType::Type>(value.type()) == QMetaType::QObjectStar &&
-                                (tex = value.value<Qt3D::Texture*>()) != Q_NULLPTR) {
-                            createRenderTexture(tex);
-                            command->m_uniforms.setTexture(binding->shaderVariableName(), tex->uuid());
-                            TextureUniform *texUniform = m_allocator->allocate<TextureUniform>();
-                            texUniform->setTextureId(tex->uuid());
-                            command->m_uniforms.setUniform(binding->shaderVariableName(), texUniform);
-                        }
-                        else {
-                            command->m_uniforms.setUniform(binding->shaderVariableName(), QUniformValue::fromVariant(value, m_allocator));
-                        }
+                    QVariant value = parameters.take(binding->parameterName());
+                    Texture *tex = Q_NULLPTR;
+                    if (static_cast<QMetaType::Type>(value.type()) == QMetaType::QObjectStar &&
+                            (tex = value.value<Qt3D::Texture*>()) != Q_NULLPTR) {
+                        createRenderTexture(tex);
+                        command->m_uniforms.setTexture(binding->shaderVariableName(), tex->uuid());
+                        TextureUniform *texUniform = m_allocator->allocate<TextureUniform>();
+                        texUniform->setTextureId(tex->uuid());
+                        command->m_uniforms.setUniform(binding->shaderVariableName(), texUniform);
+                    }
+                    else {
+                        command->m_uniforms.setUniform(binding->shaderVariableName(), QUniformValue::fromVariant(value, m_allocator));
                     }
-                    else if (binding->bindingType() == ParameterMapper::StandardUniform)
-                        command->m_uniforms.setUniform(binding->shaderVariableName(),
-                                                       (this->*m_standardUniformSetters[static_cast<Parameter::StandardUniform>(parameters.take(binding->parameterName()).toInt())])(m_renderCamera, command->m_worldMatrix));
                 }
             }
 
-            if (!parameters.empty()) {
-                // Check for default uniform names
-                // Add them if found
-                // Otherwise consider additional parameters as user defined uniforms that did not require binding
-                qDebug() << "There are params remaining" << parameters.keys();
+            // If there are remaining parameters, those are set as uniforms
+            Q_FOREACH (const QString &paramName, parameters.keys()) {
+                // TO DO : Handle textures here as well
+                if (uniformNames.contains(paramName))
+                    command->m_uniforms.setUniform(paramName, QUniformValue::fromVariant(parameters[paramName], m_allocator));
+                else
+                    qWarning() << paramName << "is unused by the current shader";
             }
-
         }
 
     }
diff --git a/src/render/backend/renderview.h b/src/render/backend/renderview.h
index 1761e6fcf..97551e6fc 100644
--- a/src/render/backend/renderview.h
+++ b/src/render/backend/renderview.h
@@ -101,6 +101,7 @@ public:
     int frameIndex() const { return m_frameIndex; }
 
 private:
+
     void computeViewport(ViewportNode *viewportNode);
     bool checkContainedWithinLayer(const QUuid &entityUuid);
 
@@ -133,9 +134,11 @@ private:
     // A dedicated ResourcesManager might improve performances later on
     // We could have pre allocated/persistent rendercommands that we reuse in the RenderQueue
 
-    typedef QHash<Parameter::StandardUniform, QUniformValue* (RenderView::*)(RenderCamera *c, const QMatrix4x4& model) const> standardUniformsPFuncsHash;
+    typedef QHash<QString, QUniformValue* (RenderView::*)(RenderCamera *c, const QMatrix4x4& model) const> standardUniformsPFuncsHash;
     static  standardUniformsPFuncsHash m_standardUniformSetters;
     static standardUniformsPFuncsHash initializeStandardUniformSetters();
+    static QStringList m_standardAttributesNames;
+    static QStringList initializeStandardAttributeNames();
 
     QUniformValue *modelMatrix(RenderCamera *, const QMatrix4x4& model) const;
     QUniformValue *viewMatrix(RenderCamera *c, const QMatrix4x4&) const;
diff --git a/src/render/frontend/parameter.h b/src/render/frontend/parameter.h
index 6d4f562fc..c8b439dbd 100644
--- a/src/render/frontend/parameter.h
+++ b/src/render/frontend/parameter.h
@@ -54,35 +54,11 @@ class QT3DRENDERERSHARED_EXPORT Parameter : public QNode
 {
     Q_OBJECT
     Q_ENUMS(OpenGLTypes)
-    Q_ENUMS(StandardUniform)
     Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged)
     Q_PROPERTY(OpenGLTypes datatype READ datatype WRITE setDatatype NOTIFY datatypeChanged)
     Q_PROPERTY(QVariant value READ value WRITE setValue NOTIFY valueChanged)
 
 public:
-    // FIXME - sort this by frequency, to minimize the size of the
-    // vector in RenderShader. (We want to use compact storage, but we index
-    // by this enum, and resize to the largest value)
-    // Will be moved out of parameter
-    enum StandardUniform
-    {
-        None = -1,
-
-        ModelMatrix = 0,
-        ViewMatrix,
-        ProjectionMatrix,
-        ModelView,
-        ModelViewProjection,
-
-        ModelInverse,
-        ViewInverse,
-        ProjectionInverse,
-        ModelViewInverse,
-        ModelViewProjectionInverse,
-
-        ModelNormal,
-        ModelViewNormal
-    };
 
     enum OpenGLTypes
     {
@@ -155,6 +131,5 @@ private:
 QT_END_NAMESPACE
 
 Q_DECLARE_METATYPE(Qt3D::Parameter *)
-Q_DECLARE_METATYPE(Qt3D::Parameter::StandardUniform)
 
 #endif // QT3D_PARAMETER_H
diff --git a/src/render/io/gltfparser.cpp b/src/render/io/gltfparser.cpp
index e0777efc7..dffd1ee7e 100644
--- a/src/render/io/gltfparser.cpp
+++ b/src/render/io/gltfparser.cpp
@@ -137,31 +137,31 @@ const QString KEY_VERTEX_SHADER   = QStringLiteral("vertexShader");
 const QString KEY_FRAGMENT_SHADER = QStringLiteral("fragmentShader");
 const QString KEY_INTERNAL_FORMAT = QStringLiteral("internalFormat");
 
-Parameter::StandardUniform parseSemanticName(const QByteArray& s)
-{
-    if (s == "MODEL")           return Parameter::ModelMatrix;
-    if (s == "VIEW")            return Parameter::ViewMatrix;
-    if (s == "PROJECTION")      return Parameter::ProjectionMatrix;
-    if (s == "MODELVIEW")       return Parameter::ModelView;
-    if (s == "MODELVIEWPROJECTION")
-        return Parameter::ModelViewProjection;
-
-    if (s == "MODELINVERSE")    return Parameter::ModelInverse;
-    if (s == "VIEWINVERSE")     return Parameter::ViewInverse;
-    if (s == "PROJECTIONINVERSE")
-        return Parameter::ProjectionInverse;
-    if (s == "MODELVIEWINVERSE")
-        return Parameter::ModelViewInverse;
-    if (s == "MODELVIEWPROJECTIONINVERSE")
-        return Parameter::ModelViewProjectionInverse;
-
-    if (s == "MODELINVERSETRANSPOSE")
-        return Parameter::ModelNormal;
-    if (s == "MODELVIEWINVERSETRANSPOSE")
-        return Parameter::ModelViewNormal;
-
-    return Parameter::None;
-}
+//Parameter::StandardUniform parseSemanticName(const QByteArray& s)
+//{
+//    if (s == "MODEL")           return Parameter::ModelMatrix;
+//    if (s == "VIEW")            return Parameter::ViewMatrix;
+//    if (s == "PROJECTION")      return Parameter::ProjectionMatrix;
+//    if (s == "MODELVIEW")       return Parameter::ModelView;
+//    if (s == "MODELVIEWPROJECTION")
+//        return Parameter::ModelViewProjection;
+
+//    if (s == "MODELINVERSE")    return Parameter::ModelInverse;
+//    if (s == "VIEWINVERSE")     return Parameter::ViewInverse;
+//    if (s == "PROJECTIONINVERSE")
+//        return Parameter::ProjectionInverse;
+//    if (s == "MODELVIEWINVERSE")
+//        return Parameter::ModelViewInverse;
+//    if (s == "MODELVIEWPROJECTIONINVERSE")
+//        return Parameter::ModelViewProjectionInverse;
+
+//    if (s == "MODELINVERSETRANSPOSE")
+//        return Parameter::ModelNormal;
+//    if (s == "MODELVIEWINVERSETRANSPOSE")
+//        return Parameter::ModelViewNormal;
+
+//    return Parameter::None;
+//}
 
 Parameter::OpenGLTypes parseType(const QByteArray &s)
 {
@@ -798,7 +798,7 @@ void GLTFParser::processJSONTechnique( QString id, QJsonObject jsonObj )
         // The Standard has changed, it doesn't return the raw int value for a type
         // But a string
         Parameter* p = new Parameter(t, pname, parseType(po.value(KEY_TYPE).toString().toUtf8()));
-        Parameter::StandardUniform su = parseSemanticName(semantic.toUtf8());
+//        Parameter::StandardUniform su = parseSemanticName(semantic.toUtf8());
 //        if (su != Parameter::None) {
 //            p->setStandardUniform(su);
 //        } else {
diff --git a/src/render/shaders/diffuse.vert b/src/render/shaders/diffuse.vert
index 987441ecd..9513c9c2d 100644
--- a/src/render/shaders/diffuse.vert
+++ b/src/render/shaders/diffuse.vert
@@ -8,14 +8,14 @@ in vec3 vertexNormal;
 out vec3 position;
 out vec3 normal;
 
-uniform mat4 modelViewMatrix;
-uniform mat3 normalMatrix;
-uniform mat4 mvp;
+uniform mat4 modelView;
+uniform mat3 modelViewNormal;
+uniform mat4 modelViewProjection;
 
 void main()
 {
-    normal = normalize( normalMatrix * vertexNormal );
-    position = vec3( modelViewMatrix * vec4( vertexPosition, 1.0 ) );
+    normal = normalize( modelViewNormal * vertexNormal );
+    position = vec3( modelView * vec4( vertexPosition, 1.0 ) );
 
-    gl_Position = mvp * vec4( vertexPosition, 1.0 );
+    gl_Position = modelViewProjection * vec4( vertexPosition, 1.0 );
 }