QShaderProgramBuilder: add properties to access generated shader code

Change-Id: Ib4d448198b2f53850ff0c9b1f2ff4d2d905eea26
Reviewed-by: Mike Krus <mike.krus@kdab.com>
Reviewed-by: Sean Harmer <sean.harmer@kdab.com>

4 files changed, 213 insertions, 0 deletions

diff --git a/src/render/materialsystem/qshaderprogrambuilder.cpp b/src/render/materialsystem/qshaderprogrambuilder.cpp
index 9318f96af..84dd33372 100644
--- a/src/render/materialsystem/qshaderprogrambuilder.cpp
+++ b/src/render/materialsystem/qshaderprogrambuilder.cpp
@@ -94,6 +94,53 @@ QShaderProgramBuilder::QShaderProgramBuilder(QShaderProgramBuilderPrivate &dd, Q
 {
 }
 
+void QShaderProgramBuilder::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &change)
+{
+    Q_D(QShaderProgramBuilder);
+    if (change->type() == Qt3DCore::PropertyUpdated) {
+        const Qt3DCore::QPropertyUpdatedChangePtr e = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(change);
+        if (e->propertyName() == QByteArrayLiteral("generatedShaderCode")) {
+            const bool blocked = blockNotifications(true);
+            const QPair<int, QByteArray> data = e->value().value<QPair<int, QByteArray>>();
+
+            switch (data.first) {
+            case QShaderProgram::Vertex: {
+                d->m_vertexShaderCode = data.second;
+                emit vertexShaderCodeChanged(d->m_vertexShaderCode);
+                break;
+            }
+            case QShaderProgram::Fragment:{
+                d->m_fragmentShaderCode = data.second;
+                emit fragmentShaderCodeChanged(d->m_fragmentShaderCode);
+                break;
+            }
+            case QShaderProgram::Geometry: {
+                d->m_geometryShaderCode = data.second;
+                emit geometryShaderCodeChanged(d->m_geometryShaderCode);
+                break;
+            }
+            case QShaderProgram::Compute: {
+                d->m_computeShaderCode = data.second;
+                emit computeShaderCodeChanged(d->m_computeShaderCode);
+                break;
+            }
+            case QShaderProgram::TessellationControl: {
+                d->m_tessControlShaderCode = data.second;
+                emit tessellationControlShaderCodeChanged(d->m_tessControlShaderCode);
+                break;
+            }
+            case QShaderProgram::TessellationEvaluation: {
+                d->m_tessEvalShaderCode = data.second;
+                emit tessellationEvaluationShaderCodeChanged(d->m_tessEvalShaderCode);
+                break;
+            }
+            }
+
+            blockNotifications(blocked);
+        }
+    }
+}
+
 /*!
     \qmlproperty string ShaderProgramBuilder::shaderProgram
 
@@ -311,6 +358,114 @@ QUrl QShaderProgramBuilder::computeShaderGraph() const
     return d->m_computeShaderGraph;
 }
 
+/*!
+    \qmlproperty string ShaderProgramBuilder:vertexShaderCode
+
+    Holds the generated vertex shader code
+    \since 2.13
+*/
+/*!
+    \property QShaderProgram:Builder:vertexShaderCode
+
+    Holds the generate vertex shader code.
+    \since 5.13
+*/
+QByteArray QShaderProgramBuilder::vertexShaderCode() const
+{
+    Q_D(const QShaderProgramBuilder);
+    return d->m_vertexShaderCode;
+}
+
+/*!
+    \qmlproperty string ShaderProgramBuilder:tessellationControlShaderCode
+
+    Holds the generated tessellation control shader code
+    \since 2.13
+*/
+/*!
+    \property QShaderProgram:Builder:tessellationControlShaderCode
+
+    Holds the generate tessellation control shader code.
+    \since 5.13
+*/
+QByteArray QShaderProgramBuilder::tessellationControlShaderCode() const
+{
+    Q_D(const QShaderProgramBuilder);
+    return d->m_tessControlShaderCode;
+}
+
+/*!
+    \qmlproperty string ShaderProgramBuilder:tessellationEvaluationShaderCode
+
+    Holds the generated tessellation evaluation shader code
+    \since 2.13
+*/
+/*!
+    \property QShaderProgram:Builder:tessellationEvaluationShaderCode
+
+    Holds the generate tessellation evaluation shader code.
+    \since 5.13
+*/
+QByteArray QShaderProgramBuilder::tessellationEvaluationShaderCode() const
+{
+    Q_D(const QShaderProgramBuilder);
+    return d->m_tessEvalShaderCode;
+}
+
+/*!
+    \qmlproperty string ShaderProgramBuilder:geometryShaderCode
+
+    Holds the generated geometry shader code
+    \since 2.13
+*/
+/*!
+    \property QShaderProgram:Builder:geometryShaderCode
+
+    Holds the generate geometry shader code.
+    \since 5.13
+*/
+QByteArray QShaderProgramBuilder::geometryShaderCode() const
+{
+    Q_D(const QShaderProgramBuilder);
+    return d->m_geometryShaderCode;
+}
+
+/*!
+    \qmlproperty string ShaderProgramBuilder::fragmentShaderCode
+
+    Holds the generated fragment shader code
+    \since 2.13
+*/
+/*!
+    \property QShaderProgram:Builder:fragmentShaderCode
+
+    Holds the generate fragment shader code.
+    \since 5.13
+*/
+QByteArray QShaderProgramBuilder::fragmentShaderCode() const
+{
+    Q_D(const QShaderProgramBuilder);
+    return d->m_fragmentShaderCode;
+}
+
+/*!
+    \qmlproperty string ShaderProgramBuilder::computeShaderCode
+
+    Holds the generated compute shader code
+    \since 2.13
+*/
+/*!
+    \property QShaderProgram:Builder:computeShaderCode
+
+    Holds the generate compute shader code.
+    \since 5.13
+*/
+QByteArray QShaderProgramBuilder::computeShaderCode() const
+{
+    Q_D(const QShaderProgramBuilder);
+    return d->m_computeShaderCode;
+}
+
 Qt3DCore::QNodeCreatedChangeBasePtr QShaderProgramBuilder::createNodeCreationChange() const
 {
     auto creationChange = Qt3DCore::QNodeCreatedChangePtr<QShaderProgramBuilderData>::create(this);
diff --git a/src/render/materialsystem/qshaderprogrambuilder.h b/src/render/materialsystem/qshaderprogrambuilder.h
index fbbf7c752..532aa7d73 100644
--- a/src/render/materialsystem/qshaderprogrambuilder.h
+++ b/src/render/materialsystem/qshaderprogrambuilder.h
@@ -63,6 +63,12 @@ class QT3DRENDERSHARED_EXPORT QShaderProgramBuilder : public Qt3DCore::QNode
     Q_PROPERTY(QUrl geometryShaderGraph READ geometryShaderGraph WRITE setGeometryShaderGraph NOTIFY geometryShaderGraphChanged)
     Q_PROPERTY(QUrl fragmentShaderGraph READ fragmentShaderGraph WRITE setFragmentShaderGraph NOTIFY fragmentShaderGraphChanged)
     Q_PROPERTY(QUrl computeShaderGraph READ computeShaderGraph WRITE setComputeShaderGraph NOTIFY computeShaderGraphChanged)
+    Q_PROPERTY(QByteArray vertexShaderCode READ vertexShaderCode NOTIFY vertexShaderCodeChanged REVISION 13)
+    Q_PROPERTY(QByteArray tessellationControlShaderCode READ tessellationControlShaderCode NOTIFY tessellationControlShaderCodeChanged REVISION 13)
+    Q_PROPERTY(QByteArray tessellationEvaluationShaderCode READ tessellationEvaluationShaderCode  NOTIFY tessellationEvaluationShaderCodeChanged REVISION 13)
+    Q_PROPERTY(QByteArray geometryShaderCode READ geometryShaderCode NOTIFY geometryShaderCodeChanged REVISION 13)
+    Q_PROPERTY(QByteArray fragmentShaderCode READ fragmentShaderCode NOTIFY fragmentShaderCodeChanged REVISION 13)
+    Q_PROPERTY(QByteArray computeShaderCode READ computeShaderCode NOTIFY computeShaderCodeChanged REVISION 13)
 
 public:
     explicit QShaderProgramBuilder(Qt3DCore::QNode *parent = nullptr);
@@ -76,6 +82,12 @@ public:
     QUrl geometryShaderGraph() const;
     QUrl fragmentShaderGraph() const;
     QUrl computeShaderGraph() const;
+    QByteArray vertexShaderCode() const;
+    QByteArray tessellationControlShaderCode() const;
+    QByteArray tessellationEvaluationShaderCode() const;
+    QByteArray geometryShaderCode() const;
+    QByteArray fragmentShaderCode() const;
+    QByteArray computeShaderCode() const;
 
 public Q_SLOTS:
     void setShaderProgram(Qt3DRender::QShaderProgram *program);
@@ -96,9 +108,16 @@ Q_SIGNALS:
     void geometryShaderGraphChanged(const QUrl &geometryShaderGraph);
     void fragmentShaderGraphChanged(const QUrl &fragmentShaderGraph);
     void computeShaderGraphChanged(const QUrl &computeShaderGraph);
+    void vertexShaderCodeChanged(const QByteArray &vertexShaderCode);
+    void tessellationControlShaderCodeChanged(const QByteArray &tessellationControlShaderCode);
+    void tessellationEvaluationShaderCodeChanged(const QByteArray &tessellationEvaluationShaderCode);
+    void geometryShaderCodeChanged(const QByteArray &geometryShaderCode);
+    void fragmentShaderCodeChanged(const QByteArray &fragmentShaderCode);
+    void computeShaderCodeChanged(const QByteArray &computeShaderCode);
 
 protected:
     explicit QShaderProgramBuilder(QShaderProgramBuilderPrivate &dd, Qt3DCore::QNode *parent = nullptr);
+    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &change) override;
 
 private:
     Q_DECLARE_PRIVATE(QShaderProgramBuilder)
diff --git a/src/render/materialsystem/qshaderprogrambuilder_p.h b/src/render/materialsystem/qshaderprogrambuilder_p.h
index e1b470229..2ac765a1d 100644
--- a/src/render/materialsystem/qshaderprogrambuilder_p.h
+++ b/src/render/materialsystem/qshaderprogrambuilder_p.h
@@ -74,6 +74,12 @@ public:
     QUrl m_geometryShaderGraph;
     QUrl m_fragmentShaderGraph;
     QUrl m_computeShaderGraph;
+    QByteArray m_vertexShaderCode;
+    QByteArray m_tessControlShaderCode;
+    QByteArray m_tessEvalShaderCode;
+    QByteArray m_geometryShaderCode;
+    QByteArray m_fragmentShaderCode;
+    QByteArray m_computeShaderCode;
 };
 
 struct QShaderProgramBuilderData
diff --git a/src/render/materialsystem/shaderbuilder.cpp b/src/render/materialsystem/shaderbuilder.cpp
index 283866d68..e0683332f 100644
--- a/src/render/materialsystem/shaderbuilder.cpp
+++ b/src/render/materialsystem/shaderbuilder.cpp
@@ -40,6 +40,7 @@
 #include "shaderbuilder_p.h"
 
 #include <Qt3DRender/private/qshaderprogrambuilder_p.h>
+#include <Qt3DRender/qshaderprogram.h>
 #include <Qt3DRender/private/qurlhelper_p.h>
 
 #include <QtGui/private/qshaderformat_p.h>
@@ -111,6 +112,31 @@ using namespace Qt3DCore;
 namespace Qt3DRender {
 namespace Render {
 
+
+namespace {
+
+QShaderProgram::ShaderType toQShaderProgramType(ShaderBuilder::ShaderType type)
+{
+    switch (type) {
+    case ShaderBuilder::ShaderType::Vertex:
+        return QShaderProgram::Vertex;
+    case ShaderBuilder::ShaderType::TessellationControl:
+        return QShaderProgram::TessellationControl;
+    case ShaderBuilder::ShaderType::TessellationEvaluation:
+        return QShaderProgram::TessellationEvaluation;
+    case ShaderBuilder::ShaderType::Geometry:
+        return QShaderProgram::Geometry;
+    case ShaderBuilder::ShaderType::Fragment:
+        return QShaderProgram::Fragment;
+    case ShaderBuilder::ShaderType::Compute:
+        return QShaderProgram::Compute;
+    default:
+        Q_UNREACHABLE();
+    }
+}
+
+} // anonymous
+
 QString ShaderBuilder::getPrototypesFile()
 {
     return qt3dGlobalShaderPrototypes->prototypesFile();
@@ -284,6 +310,13 @@ void ShaderBuilder::generateCode(ShaderBuilder::ShaderType type)
     const auto code = generator.createShaderCode(m_enabledLayers);
     m_codes.insert(type, deincludify(code, graphPath + QStringLiteral(".glsl")));
     m_dirtyTypes.remove(type);
+
+    // Send notification to the frontend
+    Qt3DCore::QPropertyUpdatedChangePtr propertyChange = Qt3DCore::QPropertyUpdatedChangePtr::create(peerId());
+    propertyChange->setDeliveryFlags(Qt3DCore::QSceneChange::DeliverToAll);
+    propertyChange->setPropertyName("generatedShaderCode");
+    propertyChange->setValue(QVariant::fromValue(qMakePair(int(toQShaderProgramType(type)), m_codes.value(type))));
+    notifyObservers(propertyChange);
 }
 
 void ShaderBuilder::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)