Add support for remaining shader stages and rename some properties

Examples updated to reflect new QShaderProgram property names.

Next commit will add a new example to test the handling of tessellation
and geometry shader stages. We need to somehow expose buffers and image
units to make use of compute shaders.

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

1 files changed, 270 insertions, 52 deletions

diff --git a/src/render/frontend/qshaderprogram.cpp b/src/render/frontend/qshaderprogram.cpp
index c63eda809..e9d4c5c5b 100644
--- a/src/render/frontend/qshaderprogram.cpp
+++ b/src/render/frontend/qshaderprogram.cpp
@@ -65,11 +65,19 @@ void QShaderProgram::copy(const QNode *ref)
     QAbstractShader::copy(ref);
     const QShaderProgram *prog = qobject_cast<const QShaderProgram *>(ref);
     if (prog != Q_NULLPTR) {
-        // TO DO : Move loading to the backend
-        d->m_vertexSourceFile = prog->vertexSourceFile();
-        d->m_fragmentSourceFile = prog->fragmentSourceFile();
-        d->m_cachedFragmentCode = prog->d_func()->m_cachedFragmentCode;
-        d->m_cachedVertexCode = prog->d_func()->m_cachedVertexCode;
+        d->m_vertexSourceFile = prog->d_func()->m_vertexSourceFile;
+        d->m_tessControlSourceFile = prog->d_func()->m_tessControlSourceFile;
+        d->m_tessEvalSourceFile = prog->d_func()->m_tessEvalSourceFile;
+        d->m_geometrySourceFile = prog->d_func()->m_geometrySourceFile;
+        d->m_fragmentSourceFile = prog->d_func()->m_fragmentSourceFile;
+        d->m_computeSourceFile = prog->d_func()->m_computeSourceFile;
+
+        d->m_vertexShaderCode = prog->d_func()->m_vertexShaderCode;
+        d->m_tessControlShaderCode = prog->d_func()->m_tessControlShaderCode;
+        d->m_tessEvalShaderCode = prog->d_func()->m_tessEvalShaderCode;
+        d->m_geometryShaderCode = prog->d_func()->m_geometryShaderCode;
+        d->m_fragmentShaderCode = prog->d_func()->m_fragmentShaderCode;
+        d->m_computeShaderCode = prog->d_func()->m_computeShaderCode;
     }
 }
 
@@ -83,98 +91,308 @@ QShaderProgram *QShaderProgram::doClone(QNode *clonedParent) const
     return new QShaderProgram(clonedParent);
 }
 
-void QShaderProgram::setVertexSourceFile(const QString& vertexSourceFile)
+void QShaderProgram::setVertexShaderSourceFile(const QString& vertexShaderSourceFile)
 {
     Q_D(QShaderProgram);
-    if (vertexSourceFile != d->m_vertexSourceFile) {
-        d->m_vertexSourceFile = vertexSourceFile;
-        emit vertexSourceFileChanged();
-
-        if (d->m_changeArbiter != Q_NULLPTR) {
-            QScenePropertyChangePtr e(new QScenePropertyChange(NodeUpdated, this));
-            e->setPropertyName(QByteArrayLiteral("vertexSourceFile"));
-            e->setValue(vertexSourceFile);
-            notifyObservers(e);
-        }
+    if (vertexShaderSourceFile != d->m_vertexSourceFile) {
+        d->m_vertexSourceFile = vertexShaderSourceFile;
+        notifyPropertyChange(QByteArrayLiteral("vertexSourceFile"),
+                             vertexShaderSourceFile);
+        emit vertexShaderSourceFileChanged();
     }
 }
 
-QString QShaderProgram::vertexSourceFile() const
+QString QShaderProgram::vertexShaderSourceFile() const
 {
     Q_D(const QShaderProgram);
     return d->m_vertexSourceFile;
 }
 
-void QShaderProgram::setFragmentSourceFile(const QString& fragmentSourceFile)
+void QShaderProgram::setTessellationControlShaderSourceFile(const QString &tessellationControlShaderSourceFile)
 {
     Q_D(QShaderProgram);
-    if (fragmentSourceFile != d->m_fragmentSourceFile) {
-        d->m_fragmentSourceFile = fragmentSourceFile;
-        emit fragmentSourceFileChanged();
+    if (tessellationControlShaderSourceFile != d->m_tessControlSourceFile) {
+        d->m_tessControlSourceFile = tessellationControlShaderSourceFile;
+        notifyPropertyChange(QByteArrayLiteral("tessellationControlShaderSourceFile"),
+                             tessellationControlShaderSourceFile);
+        emit tessellationControlShaderSourceFileChanged();
+    }
+}
+
+QString QShaderProgram::tessellationControlShaderSourceFile() const
+{
+    Q_D(const QShaderProgram);
+    return d->m_tessControlSourceFile;
+}
 
-        if (d->m_changeArbiter != Q_NULLPTR) {
-            QScenePropertyChangePtr e(new QScenePropertyChange(NodeUpdated, this));
-            e->setPropertyName(QByteArrayLiteral("fragmentSourceFile"));
-            e->setValue(fragmentSourceFile);
-            notifyObservers(e);
-        }
+void QShaderProgram::setTessellationEvaluationShaderSourceFile(const QString &tessellationEvaluationShaderSourceFile)
+{
+    Q_D(QShaderProgram);
+    if (tessellationEvaluationShaderSourceFile != d->m_tessEvalSourceFile) {
+        d->m_tessEvalSourceFile = tessellationEvaluationShaderSourceFile;
+        notifyPropertyChange(QByteArrayLiteral("tessellationEvaluationShaderSourceFile"),
+                             tessellationEvaluationShaderSourceFile);
+        emit tessellationEvaluationShaderSourceFileChanged();
     }
 }
 
-QString QShaderProgram::fragmentSourceFile() const
+QString QShaderProgram::tessellationEvaluationShaderSourceFile() const
+{
+    Q_D(const QShaderProgram);
+    return d->m_tessEvalSourceFile;
+}
+
+void QShaderProgram::setGeometryShaderSourceFile(const QString &geometryShaderSourceFile)
+{
+    Q_D(QShaderProgram);
+    if (geometryShaderSourceFile != d->m_geometrySourceFile) {
+        d->m_geometrySourceFile = geometryShaderSourceFile;
+        notifyPropertyChange(QByteArrayLiteral("geometryShaderSourceFile"),
+                             geometryShaderSourceFile);
+        emit geometryShaderSourceFileChanged();
+    }
+}
+
+QString QShaderProgram::geometryShaderSourceFile() const
+{
+    Q_D(const QShaderProgram);
+    return d->m_geometrySourceFile;
+}
+
+void QShaderProgram::setFragmentShaderSourceFile(const QString& fragmentShaderSourceFile)
+{
+    Q_D(QShaderProgram);
+    if (fragmentShaderSourceFile != d->m_fragmentSourceFile) {
+        d->m_fragmentSourceFile = fragmentShaderSourceFile;
+        notifyPropertyChange(QByteArrayLiteral("fragmentSourceFile"),
+                             fragmentShaderSourceFile);
+        emit fragmentShaderSourceFileChanged();
+    }
+}
+
+QString QShaderProgram::fragmentShaderSourceFile() const
 {
     Q_D(const QShaderProgram);
     return d->m_fragmentSourceFile;
 }
 
+void QShaderProgram::setComputeShaderSourceFile(const QString &computeShaderSourceFile)
+{
+    Q_D(QShaderProgram);
+    if (computeShaderSourceFile != d->m_computeSourceFile) {
+        d->m_computeSourceFile = computeShaderSourceFile;
+        notifyPropertyChange(QByteArrayLiteral("computeShaderSourceFile"),
+                             computeShaderSourceFile);
+        emit computeShaderSourceFileChanged();
+    }
+}
+
+QString QShaderProgram::computeShaderSourceFile() const
+{
+    Q_D(const QShaderProgram);
+    return d->m_computeSourceFile;
+}
+
+void QShaderProgram::setShaderSourceFile(ShaderType type, const QString &sourceFile)
+{
+    switch (type) {
+    case Vertex:
+        setVertexShaderSourceFile(sourceFile);
+        break;
+    case TessellationControl:
+        setTessellationControlShaderSourceFile(sourceFile);
+        break;
+    case TessellationEvaluation:
+        setTessellationEvaluationShaderSourceFile(sourceFile);
+        break;
+    case Geometry:
+        setGeometryShaderSourceFile(sourceFile);
+        break;
+    case Fragment:
+        setFragmentShaderSourceFile(sourceFile);
+        break;
+    case Compute:
+        setComputeShaderSourceFile(sourceFile);
+        break;
+    default:
+        Q_UNREACHABLE();
+    }
+}
+
+QString QShaderProgram::shaderSourceFile(ShaderType type) const
+{
+    Q_D(const QShaderProgram);
+    switch (type) {
+    case Vertex:
+        return d->m_vertexSourceFile;
+    case TessellationControl:
+        return d->m_tessControlSourceFile;
+    case TessellationEvaluation:
+        return d->m_tessEvalSourceFile;
+    case Geometry:
+        return d->m_geometrySourceFile;
+    case Fragment:
+        return d->m_fragmentSourceFile;
+    case Compute:
+        return d->m_computeSourceFile;
+    default:
+        Q_UNREACHABLE();
+    }
+}
+
 /*!
  * Sets the vertexShader from raw data in \a vertexShader.
  */
-void QShaderProgram::setVertexShader(const QByteArray &vertexShader)
+void QShaderProgram::setVertexShaderCode(const QByteArray &vertexShaderCode)
+{
+    Q_D(QShaderProgram);
+    if (vertexShaderCode != d->m_vertexShaderCode) {
+        d->m_vertexShaderCode = vertexShaderCode;
+        notifyPropertyChange(QByteArrayLiteral("vertexSourceCode"),
+                             vertexShaderCode);
+        emit vertexShaderCodeChanged();
+    }
+}
+
+QByteArray QShaderProgram::vertexShaderCode() const
+{
+    Q_D(const QShaderProgram);
+    return d->m_vertexShaderCode;
+}
+
+void QShaderProgram::setTessellationControlShaderCode(const QByteArray &tessellationControlShaderCode)
+{
+    Q_D(QShaderProgram);
+    if (tessellationControlShaderCode != d->m_tessControlShaderCode) {
+        d->m_tessControlShaderCode = tessellationControlShaderCode;
+        notifyPropertyChange(QByteArrayLiteral("tessellationControlSourceCode"),
+                             tessellationControlShaderCode);
+        emit tessellationControlShaderCodeChanged();
+    }
+}
+
+QByteArray QShaderProgram::tessellationControlShaderCode() const
+{
+    Q_D(const QShaderProgram);
+    return d->m_tessControlShaderCode;
+}
+
+void QShaderProgram::setTessellationEvaluationShaderCode(const QByteArray &tessellationEvaluationShaderCode)
 {
     Q_D(QShaderProgram);
-    if (vertexShader != d->m_cachedVertexCode) {
-        d->m_cachedVertexCode = vertexShader;
-        emit vertexShaderChanged();
+    if (tessellationEvaluationShaderCode != d->m_tessEvalShaderCode) {
+        d->m_tessEvalShaderCode = tessellationEvaluationShaderCode;
+        notifyPropertyChange(QByteArrayLiteral("tessellationEvaluationSourceCode"),
+                             tessellationEvaluationShaderCode);
+        emit tessellationEvaluationShaderCodeChanged();
+    }
+}
+
+QByteArray QShaderProgram::tessellationEvaluationShaderCode() const
+{
+    Q_D(const QShaderProgram);
+    return d->m_tessEvalShaderCode;
+}
 
-        if (d->m_changeArbiter != Q_NULLPTR) {
-            QScenePropertyChangePtr e(new QScenePropertyChange(NodeUpdated, this));
-            e->setPropertyName(QByteArrayLiteral("vertexSourceCode"));
-            e->setValue(d->m_cachedVertexCode);
-            notifyObservers(e);
-        }
+void QShaderProgram::setGeometryShaderCode(const QByteArray &geometryShaderCode)
+{
+    Q_D(QShaderProgram);
+    if (geometryShaderCode != d->m_geometryShaderCode) {
+        d->m_geometryShaderCode = geometryShaderCode;
+        notifyPropertyChange(QByteArrayLiteral("geometrySourceCode"),
+                             geometryShaderCode);
+        emit geometryShaderCodeChanged();
     }
 }
 
+QByteArray QShaderProgram::geometryShaderCode() const
+{
+    Q_D(const QShaderProgram);
+    return d->m_geometryShaderCode;
+}
+
 /*!
  * Sets the fragmentShader from raw data in \a fragmentShader.
  */
-void QShaderProgram::setFragmentShader(const QByteArray &fragmentShader)
+void QShaderProgram::setFragmentShaderCode(const QByteArray &fragmentShaderCode)
 {
     Q_D(QShaderProgram);
-    if (fragmentShader != d->m_cachedFragmentCode) {
-        d->m_cachedFragmentCode = fragmentShader;
-        emit fragmentShaderChanged();
+    if (fragmentShaderCode != d->m_fragmentShaderCode) {
+        d->m_fragmentShaderCode = fragmentShaderCode;
+        notifyPropertyChange(QByteArrayLiteral("fragmentSourceCode"),
+                             fragmentShaderCode);
+        emit fragmentShaderCodeChanged();
+    }
+}
 
-        if (d->m_changeArbiter != Q_NULLPTR) {
-            QScenePropertyChangePtr e(new QScenePropertyChange(NodeUpdated, this));
-            e->setPropertyName(QByteArrayLiteral("fragmentSourceCode"));
-            e->setValue(d->m_cachedFragmentCode);
-            notifyObservers(e);
-        }
+QByteArray QShaderProgram::fragmentShaderCode() const
+{
+    Q_D(const QShaderProgram);
+    return d->m_fragmentShaderCode;
+}
+
+void QShaderProgram::setComputeShaderCode(const QByteArray &computeShaderCode)
+{
+    Q_D(QShaderProgram);
+    if (computeShaderCode != d->m_computeShaderCode) {
+        d->m_computeShaderCode = computeShaderCode;
+        notifyPropertyChange(QByteArrayLiteral("computeSourceCode"),
+                             computeShaderCode);
+        emit computeShaderCodeChanged();
     }
 }
 
-QByteArray QShaderProgram::vertexSourceCode() const
+QByteArray QShaderProgram::computeShaderCode() const
 {
     Q_D(const QShaderProgram);
-    return d->m_cachedVertexCode;
+    return d->m_computeShaderCode;
 }
 
-QByteArray QShaderProgram::fragmentSourceCode() const
+void QShaderProgram::setShaderCode(ShaderType type, const QByteArray &shaderCode)
+{
+    switch (type) {
+    case Vertex:
+        setVertexShaderCode(shaderCode);
+        break;
+    case TessellationControl:
+        setTessellationControlShaderCode(shaderCode);
+        break;
+    case TessellationEvaluation:
+        setTessellationEvaluationShaderCode(shaderCode);
+        break;
+    case Geometry:
+        setGeometryShaderCode(shaderCode);
+        break;
+    case Fragment:
+        setFragmentShaderCode(shaderCode);
+        break;
+    case Compute:
+        setComputeShaderCode(shaderCode);
+        break;
+    default:
+        Q_UNREACHABLE();
+    }
+}
+
+QByteArray QShaderProgram::shaderCode(ShaderType type) const
 {
     Q_D(const QShaderProgram);
-    return d->m_cachedFragmentCode;
+    switch (type) {
+    case Vertex:
+        return d->m_vertexShaderCode;
+    case TessellationControl:
+        return d->m_tessControlShaderCode;
+    case TessellationEvaluation:
+        return d->m_tessEvalShaderCode;
+    case Geometry:
+        return d->m_geometryShaderCode;
+    case Fragment:
+        return d->m_fragmentShaderCode;
+    case Compute:
+        return d->m_computeShaderCode;
+    default:
+        Q_UNREACHABLE();
+    }
 }
 
 } // of namespace Qt3D