QShaderProgram: add a format property

Can be either GLSL (default) or SPIRV at the moment. This variable will be
used by the rendering backend to know what type of shader code was provided
(e.g with Vulkan, the GLSL could be internally converted to SPIRV)

Change-Id: I1f9b734a675c581ef0721edc4464e466a18afbb0
Reviewed-by: Paul Lemire <paul.lemire@kdab.com>

2 files changed, 111 insertions, 2 deletions

diff --git a/tests/auto/render/qshaderprogram/tst_qshaderprogram.cpp b/tests/auto/render/qshaderprogram/tst_qshaderprogram.cpp
index 18dd1306a..15be26e8e 100644
--- a/tests/auto/render/qshaderprogram/tst_qshaderprogram.cpp
+++ b/tests/auto/render/qshaderprogram/tst_qshaderprogram.cpp
@@ -45,6 +45,13 @@ class tst_QShaderProgram : public Qt3DRender::QShaderProgram
 {
     Q_OBJECT
 
+public:
+    tst_QShaderProgram()
+        : Qt3DRender::QShaderProgram()
+    {
+        qRegisterMetaType<Qt3DRender::QShaderProgram::Format>("Format");
+    }
+
 private Q_SLOTS:
 
     void checkDefaultConstruction()
@@ -61,6 +68,7 @@ private Q_SLOTS:
         QCOMPARE(shaderProgram.computeShaderCode(), QByteArray());
         QCOMPARE(shaderProgram.log(), QString());
         QCOMPARE(shaderProgram.status(), Qt3DRender::QShaderProgram::NotReady);
+        QCOMPARE(shaderProgram.format(), Qt3DRender::QShaderProgram::GLSL);
     }
 
     void checkPropertyChanges()
@@ -182,6 +190,25 @@ private Q_SLOTS:
             QCOMPARE(shaderProgram.computeShaderCode(), newValue);
             QCOMPARE(spy.count(), 0);
         }
+        {
+            // WHEN
+            QSignalSpy spy(&shaderProgram, SIGNAL(formatChanged(Format)));
+            const QShaderProgram::Format newValue = QShaderProgram::SPIRV;
+            shaderProgram.setFormat(newValue);
+
+            // THEN
+            QVERIFY(spy.isValid());
+            QCOMPARE(shaderProgram.format(), newValue);
+            QCOMPARE(spy.count(), 1);
+
+            // WHEN
+            spy.clear();
+            shaderProgram.setFormat(newValue);
+
+            // THEN
+            QCOMPARE(shaderProgram.format(), newValue);
+            QCOMPARE(spy.count(), 0);
+        }
     }
 
     void checkCreationData()
@@ -195,6 +222,7 @@ private Q_SLOTS:
         shaderProgram.setGeometryShaderCode(QByteArrayLiteral("Geometry"));
         shaderProgram.setFragmentShaderCode(QByteArrayLiteral("Fragment"));
         shaderProgram.setComputeShaderCode(QByteArrayLiteral("Compute"));
+        shaderProgram.setFormat(QShaderProgram::SPIRV);
 
         // WHEN
         QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
@@ -217,6 +245,7 @@ private Q_SLOTS:
             QCOMPARE(shaderProgram.geometryShaderCode(), cloneData.geometryShaderCode);
             QCOMPARE(shaderProgram.fragmentShaderCode(), cloneData.fragmentShaderCode);
             QCOMPARE(shaderProgram.computeShaderCode(), cloneData.computeShaderCode);
+            QCOMPARE(shaderProgram.format(), cloneData.format);
             QCOMPARE(shaderProgram.id(), creationChangeData->subjectId());
             QCOMPARE(shaderProgram.isEnabled(), true);
             QCOMPARE(shaderProgram.isEnabled(), creationChangeData->isNodeEnabled());
@@ -532,6 +561,42 @@ private Q_SLOTS:
         // THEN
         QVERIFY(mainContent.indexOf(includedContent) == 0);
     }
+
+    void checkFormatPropertyUpdate()
+    {
+        // GIVEN
+        TestArbiter arbiter;
+        Qt3DRender::QShaderProgram shaderProgram;
+        arbiter.setArbiterOnNode(&shaderProgram);
+
+        QSignalSpy spy(&shaderProgram, SIGNAL(formatChanged(Format)));
+
+        // THEN
+        QVERIFY(spy.isValid());
+
+        {
+            // WHEN
+            shaderProgram.setFormat(QShaderProgram::SPIRV);
+            QCoreApplication::processEvents();
+
+            // THEN
+            QCOMPARE(spy.count(), 1);
+            QCOMPARE(arbiter.events.size(), 0);
+
+            spy.clear();
+        }
+
+        {
+            // WHEN
+            shaderProgram.setFormat(QShaderProgram::SPIRV);
+            QCoreApplication::processEvents();
+
+            // THEN
+            QCOMPARE(spy.count(), 0);
+            QCOMPARE(arbiter.events.size(), 0);
+        }
+    }
+
 };
 
 QTEST_MAIN(tst_QShaderProgram)
diff --git a/tests/auto/render/shader/tst_shader.cpp b/tests/auto/render/shader/tst_shader.cpp
index 3f0714907..a1f837010 100644
--- a/tests/auto/render/shader/tst_shader.cpp
+++ b/tests/auto/render/shader/tst_shader.cpp
@@ -42,15 +42,17 @@ private slots:
     void cleanupLeavesACoherentState();
     void dealWithPropertyChanges_data();
     void dealWithPropertyChanges();
+    void dealWithFormatChanges();
     void checkSetRendererDirtyOnInitialization();
     void allowToChangeShaderCode_data();
     void allowToChangeShaderCode();
 };
 
 
-Qt3DRender::QShaderProgram *createFrontendShader()
+Qt3DRender::QShaderProgram *createFrontendShader(Qt3DRender::QShaderProgram::Format format = Qt3DRender::QShaderProgram::GLSL)
 {
     Qt3DRender::QShaderProgram *shader = new Qt3DRender::QShaderProgram();
+    shader->setFormat(format);
 
     shader->setVertexShaderCode(QByteArrayLiteral(
                                     "#version 150"\
@@ -80,6 +82,7 @@ void tst_RenderShader::hasCoherentInitialState()
     Qt3DRender::Render::Shader *shader = new Qt3DRender::Render::Shader();
 
     QCOMPARE(shader->status(), Qt3DRender::QShaderProgram::NotReady);
+    QCOMPARE(shader->format(), Qt3DRender::QShaderProgram::GLSL);
     QVERIFY(shader->log().isEmpty());
     QCOMPARE(shader->isDirty(), false);
 }
@@ -97,11 +100,12 @@ void tst_RenderShader::matchesFrontendPeer()
     for (int i = Qt3DRender::QShaderProgram::Vertex; i <= Qt3DRender::QShaderProgram::Compute; ++i)
         QCOMPARE(backend.shaderCode()[i],
                  frontend->shaderCode(static_cast<Qt3DRender::QShaderProgram::ShaderType>(i)));
+    QCOMPARE(backend.format(), frontend->format());
 }
 
 void tst_RenderShader::cleanupLeavesACoherentState()
 {
-    QScopedPointer<Qt3DRender::QShaderProgram> frontend(createFrontendShader());
+    QScopedPointer<Qt3DRender::QShaderProgram> frontend(createFrontendShader(Qt3DRender::QShaderProgram::SPIRV));
     TestRenderer renderer;
     Qt3DRender::Render::Shader shader;
 
@@ -112,6 +116,7 @@ void tst_RenderShader::cleanupLeavesACoherentState()
 
     QCOMPARE(shader.isDirty(), false);
     QCOMPARE(shader.status(), Qt3DRender::QShaderProgram::NotReady);
+    QCOMPARE(shader.format(), Qt3DRender::QShaderProgram::GLSL);
 }
 
 void tst_RenderShader::dealWithPropertyChanges_data()
@@ -176,6 +181,45 @@ void tst_RenderShader::dealWithPropertyChanges()
     QCOMPARE(backend.isDirty(), true);
 }
 
+void tst_RenderShader::dealWithFormatChanges()
+{
+    // GIVEN
+    Qt3DRender::Render::Shader backend;
+    Qt3DRender::QShaderProgram shader;
+    TestRenderer renderer;
+    backend.setRenderer(&renderer);
+    simulateInitializationSync(&shader, &backend);
+
+    // WHEN
+    shader.setFormat(Qt3DRender::QShaderProgram::GLSL);
+    backend.syncFromFrontEnd(&shader, false);
+
+    // THEN
+    QCOMPARE(backend.format(), Qt3DRender::QShaderProgram::GLSL);
+    QCOMPARE(backend.isDirty(), false);
+    QCOMPARE(renderer.dirtyBits(), 0);
+
+    // WHEN
+    shader.setFormat(Qt3DRender::QShaderProgram::SPIRV);
+    backend.syncFromFrontEnd(&shader, false);
+
+    // THEN
+    QCOMPARE(backend.format(), Qt3DRender::QShaderProgram::SPIRV);
+    QCOMPARE(renderer.dirtyBits(), Qt3DRender::Render::AbstractRenderer::ShadersDirty);
+    QCOMPARE(backend.isDirty(), true);
+
+    renderer.resetDirty();
+    backend.unsetDirty();
+
+    // WHEN
+    shader.setFormat(Qt3DRender::QShaderProgram::SPIRV);
+    backend.syncFromFrontEnd(&shader, false);
+
+    // THEN
+    QCOMPARE(backend.isDirty(), false);
+    QCOMPARE(renderer.dirtyBits(), 0);
+}
+
 void tst_RenderShader::checkSetRendererDirtyOnInitialization()
 {
     // GIVEN