Move classes in OpenGL renderer plugin into an OpenGL namespace

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

17 files changed, 219 insertions, 210 deletions

diff --git a/tests/auto/render/opengl/computecommand/tst_computecommand.cpp b/tests/auto/render/opengl/computecommand/tst_computecommand.cpp
index 80cbfb090..3caf11c8f 100644
--- a/tests/auto/render/opengl/computecommand/tst_computecommand.cpp
+++ b/tests/auto/render/opengl/computecommand/tst_computecommand.cpp
@@ -44,11 +44,11 @@
 
 
 // tst_Renderer is a friend class of Renderer
-class tst_Renderer : public Qt3DRender::Render::Renderer
+class tst_Renderer : public Qt3DRender::Render::OpenGL::Renderer
 {
 public:
     tst_Renderer()
-        : Qt3DRender::Render::Renderer(Qt3DRender::QRenderAspect::Synchronous)
+        : Qt3DRender::Render::OpenGL::Renderer(Qt3DRender::QRenderAspect::Synchronous)
     {}
 
     ~tst_Renderer() {
diff --git a/tests/auto/render/opengl/filtercompatibletechniquejob/tst_filtercompatibletechniquejob.cpp b/tests/auto/render/opengl/filtercompatibletechniquejob/tst_filtercompatibletechniquejob.cpp
index 8b9390340..e5c34f804 100644
--- a/tests/auto/render/opengl/filtercompatibletechniquejob/tst_filtercompatibletechniquejob.cpp
+++ b/tests/auto/render/opengl/filtercompatibletechniquejob/tst_filtercompatibletechniquejob.cpp
@@ -116,9 +116,9 @@ public:
         renderer()->submissionContext()->beginDrawing(m_window.data());
     }
 
-    Render::Renderer *renderer() const
+    Render::OpenGL::Renderer *renderer() const
     {
-        return static_cast<Render::Renderer *>(d_func()->m_renderer);
+        return static_cast<Render::OpenGL::Renderer *>(d_func()->m_renderer);
     }
 
     void onRegistered() { QRenderAspect::onRegistered(); }
@@ -196,7 +196,7 @@ private Q_SLOTS:
     void checkInitialState()
     {
         // GIVEN
-        Qt3DRender::Render::FilterCompatibleTechniqueJob backendFilterCompatibleTechniqueJob;
+        Qt3DRender::Render::OpenGL::FilterCompatibleTechniqueJob backendFilterCompatibleTechniqueJob;
 
         // THEN
         QVERIFY(backendFilterCompatibleTechniqueJob.manager() == nullptr);
@@ -204,7 +204,7 @@ private Q_SLOTS:
 
         // WHEN
         Qt3DRender::Render::TechniqueManager techniqueManager;
-        Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
+        Qt3DRender::Render::OpenGL::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
         backendFilterCompatibleTechniqueJob.setManager(&techniqueManager);
         backendFilterCompatibleTechniqueJob.setRenderer(&renderer);
 
@@ -218,7 +218,7 @@ private Q_SLOTS:
     void checkRunRendererRunning()
     {
         // GIVEN
-        Qt3DRender::Render::FilterCompatibleTechniqueJob backendFilterCompatibleTechniqueJob;
+        Qt3DRender::Render::OpenGL::FilterCompatibleTechniqueJob backendFilterCompatibleTechniqueJob;
         Qt3DRender::TestAspect testAspect(buildTestScene());
 
         const bool unableToCreateContext = !testAspect.contextCreationSuccessful();
diff --git a/tests/auto/render/opengl/glshadermanager/tst_glshadermanager.cpp b/tests/auto/render/opengl/glshadermanager/tst_glshadermanager.cpp
index 83420af3b..6a5bc87ea 100644
--- a/tests/auto/render/opengl/glshadermanager/tst_glshadermanager.cpp
+++ b/tests/auto/render/opengl/glshadermanager/tst_glshadermanager.cpp
@@ -46,7 +46,7 @@ private Q_SLOTS:
 void tst_GLShaderManager::adopt()
 {
     // GIVEN
-    Qt3DRender::Render::GLShaderManager cache;
+    Qt3DRender::Render::OpenGL::GLShaderManager cache;
     Qt3DRender::QShaderProgram frontendShader1;
     Qt3DRender::QShaderProgram frontendShader2;
     TestRenderer renderer;
@@ -64,7 +64,7 @@ void tst_GLShaderManager::adopt()
     QVERIFY(backendShaderNode1.peerId() != backendShaderNode2.peerId());
 
     // WHEN
-    Qt3DRender::Render::GLShader *glShader1 = cache.createOrAdoptExisting(&backendShaderNode1);
+    Qt3DRender::Render::OpenGL::GLShader *glShader1 = cache.createOrAdoptExisting(&backendShaderNode1);
 
     // THEN
     QVERIFY(glShader1 != nullptr);
@@ -73,7 +73,7 @@ void tst_GLShaderManager::adopt()
     QCOMPARE(shaderNodeIds.first(), backendShaderNode1.peerId());
 
     // WHEN
-    Qt3DRender::Render::GLShader *glShader2 = cache.createOrAdoptExisting(&backendShaderNode2);
+    Qt3DRender::Render::OpenGL::GLShader *glShader2 = cache.createOrAdoptExisting(&backendShaderNode2);
 
     // THEN
     QCOMPARE(glShader1, glShader2);
@@ -87,7 +87,7 @@ void tst_GLShaderManager::adopt()
 void tst_GLShaderManager::lookupResource()
 {
     // GIVEN
-    Qt3DRender::Render::GLShaderManager cache;
+    Qt3DRender::Render::OpenGL::GLShaderManager cache;
     Qt3DRender::QShaderProgram frontendShader1;
     Qt3DRender::QShaderProgram frontendShader2;
     TestRenderer renderer;
@@ -104,8 +104,8 @@ void tst_GLShaderManager::lookupResource()
     cache.createOrAdoptExisting(&backendShaderNode2);
 
     // THEN
-    Qt3DRender::Render::GLShader *glShader1 = cache.lookupResource(backendShaderNode1.peerId());
-    Qt3DRender::Render::GLShader *glShader2 = cache.lookupResource(backendShaderNode2.peerId());
+    Qt3DRender::Render::OpenGL::GLShader *glShader1 = cache.lookupResource(backendShaderNode1.peerId());
+    Qt3DRender::Render::OpenGL::GLShader *glShader2 = cache.lookupResource(backendShaderNode2.peerId());
     QVERIFY(glShader1 != nullptr);
     QCOMPARE(glShader1, glShader2);
     const QVector<Qt3DCore::QNodeId> shaderNodeIds = cache.shaderIdsForProgram(glShader1);
@@ -117,7 +117,7 @@ void tst_GLShaderManager::lookupResource()
 void tst_GLShaderManager::abandon()
 {
     // GIVEN
-    Qt3DRender::Render::GLShaderManager cache;
+    Qt3DRender::Render::OpenGL::GLShaderManager cache;
     Qt3DRender::QShaderProgram frontendShader1;
     Qt3DRender::QShaderProgram frontendShader2;
     TestRenderer renderer;
@@ -132,7 +132,7 @@ void tst_GLShaderManager::abandon()
     cache.createOrAdoptExisting(&backendShaderNode2);
 
     // WHEN
-    Qt3DRender::Render::GLShader *glShader = cache.lookupResource(backendShaderNode1.peerId());
+    Qt3DRender::Render::OpenGL::GLShader *glShader = cache.lookupResource(backendShaderNode1.peerId());
     cache.abandon(glShader, &backendShaderNode1);
 
     // THEN
@@ -147,7 +147,7 @@ void tst_GLShaderManager::abandon()
     // THEN
     shaderNodeIds = cache.shaderIdsForProgram(glShader);
     QCOMPARE(shaderNodeIds.size(), 0);
-    const QVector<Qt3DRender::Render::GLShader *> releasedShaders = cache.takeAbandonned();
+    const QVector<Qt3DRender::Render::OpenGL::GLShader *> releasedShaders = cache.takeAbandonned();
     QCOMPARE(releasedShaders.size(), 1);
     QCOMPARE(releasedShaders.first(), glShader);
 }
@@ -155,7 +155,7 @@ void tst_GLShaderManager::abandon()
 void tst_GLShaderManager::insertAfterRemoval()
 {
     // GIVEN
-    Qt3DRender::Render::GLShaderManager cache;
+    Qt3DRender::Render::OpenGL::GLShaderManager cache;
     Qt3DRender::QShaderProgram frontendShader;
     TestRenderer renderer;
     Qt3DRender::Render::Shader backendShaderNode;
@@ -165,8 +165,8 @@ void tst_GLShaderManager::insertAfterRemoval()
     simulateInitialization(&frontendShader, &backendShaderNode);
 
     // WHEN
-    Qt3DRender::Render::GLShader *apiShader1 = cache.createOrAdoptExisting(&backendShaderNode);
-    const Qt3DRender::Render::GLShader *originalApiShader = apiShader1;
+    Qt3DRender::Render::OpenGL::GLShader *apiShader1 = cache.createOrAdoptExisting(&backendShaderNode);
+    const Qt3DRender::Render::OpenGL::GLShader *originalApiShader = apiShader1;
 
     // THEN
     auto apiShader2 = cache.lookupResource(frontendShader.id());
@@ -179,7 +179,7 @@ void tst_GLShaderManager::insertAfterRemoval()
     cache.abandon(apiShader1, &backendShaderNode);
 
     // THEN
-    Qt3DRender::Render::GLShader *apiShaderEmpty = cache.lookupResource(frontendShader.id());
+    Qt3DRender::Render::OpenGL::GLShader *apiShaderEmpty = cache.lookupResource(frontendShader.id());
     QVERIFY(apiShaderEmpty == nullptr);
 
     // WHEN
diff --git a/tests/auto/render/opengl/graphicshelpergl2/tst_graphicshelpergl2.cpp b/tests/auto/render/opengl/graphicshelpergl2/tst_graphicshelpergl2.cpp
index 0a43a3040..5a1d22283 100644
--- a/tests/auto/render/opengl/graphicshelpergl2/tst_graphicshelpergl2.cpp
+++ b/tests/auto/render/opengl/graphicshelpergl2/tst_graphicshelpergl2.cpp
@@ -47,6 +47,7 @@ QT_BEGIN_NAMESPACE
 
 using namespace Qt3DRender;
 using namespace Qt3DRender::Render;
+using namespace Qt3DRender::Render::OpenGL;
 
 namespace {
 
diff --git a/tests/auto/render/opengl/graphicshelpergl3_2/tst_graphicshelpergl3_2.cpp b/tests/auto/render/opengl/graphicshelpergl3_2/tst_graphicshelpergl3_2.cpp
index a4a59d7c4..08c30dc15 100644
--- a/tests/auto/render/opengl/graphicshelpergl3_2/tst_graphicshelpergl3_2.cpp
+++ b/tests/auto/render/opengl/graphicshelpergl3_2/tst_graphicshelpergl3_2.cpp
@@ -43,6 +43,7 @@
 
 using namespace Qt3DRender;
 using namespace Qt3DRender::Render;
+using namespace Qt3DRender::Render::OpenGL;
 
 namespace {
 
diff --git a/tests/auto/render/opengl/graphicshelpergl3_3/tst_graphicshelpergl3_3.cpp b/tests/auto/render/opengl/graphicshelpergl3_3/tst_graphicshelpergl3_3.cpp
index 3e4a052ba..b463e6236 100644
--- a/tests/auto/render/opengl/graphicshelpergl3_3/tst_graphicshelpergl3_3.cpp
+++ b/tests/auto/render/opengl/graphicshelpergl3_3/tst_graphicshelpergl3_3.cpp
@@ -42,6 +42,7 @@
 
 using namespace Qt3DRender;
 using namespace Qt3DRender::Render;
+using namespace Qt3DRender::Render::OpenGL;
 
 namespace {
 
diff --git a/tests/auto/render/opengl/graphicshelpergl4/tst_graphicshelpergl4.cpp b/tests/auto/render/opengl/graphicshelpergl4/tst_graphicshelpergl4.cpp
index 31024e1db..8f86f38ce 100644
--- a/tests/auto/render/opengl/graphicshelpergl4/tst_graphicshelpergl4.cpp
+++ b/tests/auto/render/opengl/graphicshelpergl4/tst_graphicshelpergl4.cpp
@@ -43,6 +43,7 @@
 
 using namespace Qt3DRender;
 using namespace Qt3DRender::Render;
+using namespace Qt3DRender::Render::OpenGL;
 
 namespace {
 
diff --git a/tests/auto/render/opengl/materialparametergathererjob/tst_materialparametergathererjob.cpp b/tests/auto/render/opengl/materialparametergathererjob/tst_materialparametergathererjob.cpp
index e6b78c47b..efd2c6603 100644
--- a/tests/auto/render/opengl/materialparametergathererjob/tst_materialparametergathererjob.cpp
+++ b/tests/auto/render/opengl/materialparametergathererjob/tst_materialparametergathererjob.cpp
@@ -107,9 +107,9 @@ public:
         d_func()->m_renderer->initialize();
     }
 
-    Render::MaterialParameterGathererJobPtr materialGathererJob() const
+    Render::OpenGL::MaterialParameterGathererJobPtr materialGathererJob() const
     {
-        Render::MaterialParameterGathererJobPtr job = Render::MaterialParameterGathererJobPtr::create();
+        Render::OpenGL::MaterialParameterGathererJobPtr job = Render::OpenGL::MaterialParameterGathererJobPtr::create();
         job->setNodeManagers(nodeManagers());
         return job;
     }
@@ -232,7 +232,7 @@ private Q_SLOTS:
         // GIVEN
         Qt3DCore::QEntity *sceneRoot = buildScene(viewportFrameGraph());
         Qt3DRender::TestAspect testAspect(sceneRoot);
-        Qt3DRender::Render::MaterialParameterGathererJobPtr gatherer = testAspect.materialGathererJob();
+        Qt3DRender::Render::OpenGL::MaterialParameterGathererJobPtr gatherer = testAspect.materialGathererJob();
 
         testAspect.initializeRenderer();
 
@@ -252,7 +252,7 @@ private Q_SLOTS:
         TestMaterial material;
         Qt3DCore::QEntity *sceneRoot = buildScene(viewportFrameGraph(), &material);
         Qt3DRender::TestAspect testAspect(sceneRoot);
-        Qt3DRender::Render::MaterialParameterGathererJobPtr gatherer = testAspect.materialGathererJob();
+        Qt3DRender::Render::OpenGL::MaterialParameterGathererJobPtr gatherer = testAspect.materialGathererJob();
 
         testAspect.initializeRenderer();
 
@@ -274,7 +274,7 @@ private Q_SLOTS:
         material.setEnabled(false);
         Qt3DCore::QEntity *sceneRoot = buildScene(viewportFrameGraph(), &material);
         Qt3DRender::TestAspect testAspect(sceneRoot);
-        Qt3DRender::Render::MaterialParameterGathererJobPtr gatherer = testAspect.materialGathererJob();
+        Qt3DRender::Render::OpenGL::MaterialParameterGathererJobPtr gatherer = testAspect.materialGathererJob();
 
         testAspect.initializeRenderer();
 
@@ -306,7 +306,7 @@ private Q_SLOTS:
 
         Qt3DCore::QEntity *sceneRoot = buildScene(frameGraphFilter, &material);
         Qt3DRender::TestAspect testAspect(sceneRoot);
-        Qt3DRender::Render::MaterialParameterGathererJobPtr gatherer = testAspect.materialGathererJob();
+        Qt3DRender::Render::OpenGL::MaterialParameterGathererJobPtr gatherer = testAspect.materialGathererJob();
 
         testAspect.initializeRenderer();
 
@@ -346,7 +346,7 @@ private Q_SLOTS:
 
         Qt3DCore::QEntity *sceneRoot = buildScene(frameGraphFilter, &material);
         Qt3DRender::TestAspect testAspect(sceneRoot);
-        Qt3DRender::Render::MaterialParameterGathererJobPtr gatherer = testAspect.materialGathererJob();
+        Qt3DRender::Render::OpenGL::MaterialParameterGathererJobPtr gatherer = testAspect.materialGathererJob();
 
         testAspect.initializeRenderer();
 
@@ -382,7 +382,7 @@ private Q_SLOTS:
 
         Qt3DCore::QEntity *sceneRoot = buildScene(frameGraphFilter, &material);
         Qt3DRender::TestAspect testAspect(sceneRoot);
-        Qt3DRender::Render::MaterialParameterGathererJobPtr gatherer = testAspect.materialGathererJob();
+        Qt3DRender::Render::OpenGL::MaterialParameterGathererJobPtr gatherer = testAspect.materialGathererJob();
 
         testAspect.initializeRenderer();
 
@@ -416,7 +416,7 @@ private Q_SLOTS:
 
         Qt3DCore::QEntity *sceneRoot = buildScene(frameGraphFilter, &material);
         Qt3DRender::TestAspect testAspect(sceneRoot);
-        Qt3DRender::Render::MaterialParameterGathererJobPtr gatherer = testAspect.materialGathererJob();
+        Qt3DRender::Render::OpenGL::MaterialParameterGathererJobPtr gatherer = testAspect.materialGathererJob();
 
         testAspect.initializeRenderer();
 
@@ -456,7 +456,7 @@ private Q_SLOTS:
 
         Qt3DCore::QEntity *sceneRoot = buildScene(frameGraphFilter, &material);
         Qt3DRender::TestAspect testAspect(sceneRoot);
-        Qt3DRender::Render::MaterialParameterGathererJobPtr gatherer = testAspect.materialGathererJob();
+        Qt3DRender::Render::OpenGL::MaterialParameterGathererJobPtr gatherer = testAspect.materialGathererJob();
 
         testAspect.initializeRenderer();
 
@@ -509,7 +509,7 @@ private Q_SLOTS:
             material.es2Pass()->addParameter(passParam);
 
             Qt3DRender::TestAspect testAspect(sceneRoot);
-            Qt3DRender::Render::MaterialParameterGathererJobPtr gatherer = testAspect.materialGathererJob();
+            Qt3DRender::Render::OpenGL::MaterialParameterGathererJobPtr gatherer = testAspect.materialGathererJob();
             testAspect.initializeRenderer();
 
             QCOMPARE(testAspect.nodeManagers()->materialManager()->activeHandles().size(), 1);
@@ -526,10 +526,10 @@ private Q_SLOTS:
             // THEN -> RenderPassFilter wins
             QCOMPARE(gatherer->materialToPassAndParameter().size(), 1);
 
-            const QVector<Qt3DRender::Render::RenderPassParameterData> passParameterData = gatherer->materialToPassAndParameter().begin().value();
+            const QVector<Qt3DRender::Render::OpenGL::RenderPassParameterData> passParameterData = gatherer->materialToPassAndParameter().begin().value();
             QCOMPARE(passParameterData.size(), 1);
 
-            const Qt3DRender::Render::RenderPassParameterData data = passParameterData.first();
+            const Qt3DRender::Render::OpenGL::RenderPassParameterData data = passParameterData.first();
 
             QCOMPARE(data.parameterInfo.size(), 1);
             QCOMPARE(data.parameterInfo.first().handle, testAspect.nodeManagers()->parameterManager()->lookupHandle(renderPassParameter->id()));
@@ -565,7 +565,7 @@ private Q_SLOTS:
             material.es2Pass()->addParameter(passParam);
 
             Qt3DRender::TestAspect testAspect(sceneRoot);
-            Qt3DRender::Render::MaterialParameterGathererJobPtr gatherer = testAspect.materialGathererJob();
+            Qt3DRender::Render::OpenGL::MaterialParameterGathererJobPtr gatherer = testAspect.materialGathererJob();
             testAspect.initializeRenderer();
 
             QCOMPARE(testAspect.nodeManagers()->materialManager()->activeHandles().size(), 1);
@@ -582,10 +582,10 @@ private Q_SLOTS:
             // THEN -> TechniqueFilter wins
             QCOMPARE(gatherer->materialToPassAndParameter().size(), 1);
 
-            const QVector<Qt3DRender::Render::RenderPassParameterData> passParameterData = gatherer->materialToPassAndParameter().begin().value();
+            const QVector<Qt3DRender::Render::OpenGL::RenderPassParameterData> passParameterData = gatherer->materialToPassAndParameter().begin().value();
             QCOMPARE(passParameterData.size(), 1);
 
-            const Qt3DRender::Render::RenderPassParameterData data = passParameterData.first();
+            const Qt3DRender::Render::OpenGL::RenderPassParameterData data = passParameterData.first();
 
             QCOMPARE(data.parameterInfo.size(), 1);
             QCOMPARE(data.parameterInfo.first().handle, testAspect.nodeManagers()->parameterManager()->lookupHandle(techniqueFilterParameter->id()));
@@ -620,7 +620,7 @@ private Q_SLOTS:
             material.es2Pass()->addParameter(passParam);
 
             Qt3DRender::TestAspect testAspect(sceneRoot);
-            Qt3DRender::Render::MaterialParameterGathererJobPtr gatherer = testAspect.materialGathererJob();
+            Qt3DRender::Render::OpenGL::MaterialParameterGathererJobPtr gatherer = testAspect.materialGathererJob();
             testAspect.initializeRenderer();
 
             QCOMPARE(testAspect.nodeManagers()->materialManager()->activeHandles().size(), 1);
@@ -637,10 +637,10 @@ private Q_SLOTS:
             // THEN -> TechniqueFilter wins
             QCOMPARE(gatherer->materialToPassAndParameter().size(), 1);
 
-            const QVector<Qt3DRender::Render::RenderPassParameterData> passParameterData = gatherer->materialToPassAndParameter().begin().value();
+            const QVector<Qt3DRender::Render::OpenGL::RenderPassParameterData> passParameterData = gatherer->materialToPassAndParameter().begin().value();
             QCOMPARE(passParameterData.size(), 1);
 
-            const Qt3DRender::Render::RenderPassParameterData data = passParameterData.first();
+            const Qt3DRender::Render::OpenGL::RenderPassParameterData data = passParameterData.first();
 
             QCOMPARE(data.parameterInfo.size(), 1);
             QCOMPARE(data.parameterInfo.first().handle, testAspect.nodeManagers()->parameterManager()->lookupHandle(materialParameter->id()));
@@ -674,7 +674,7 @@ private Q_SLOTS:
             material.es2Pass()->addParameter(passParam);
 
             Qt3DRender::TestAspect testAspect(sceneRoot);
-            Qt3DRender::Render::MaterialParameterGathererJobPtr gatherer = testAspect.materialGathererJob();
+            Qt3DRender::Render::OpenGL::MaterialParameterGathererJobPtr gatherer = testAspect.materialGathererJob();
             testAspect.initializeRenderer();
 
             QCOMPARE(testAspect.nodeManagers()->materialManager()->activeHandles().size(), 1);
@@ -691,10 +691,10 @@ private Q_SLOTS:
             // THEN -> TechniqueFilter wins
             QCOMPARE(gatherer->materialToPassAndParameter().size(), 1);
 
-            const QVector<Qt3DRender::Render::RenderPassParameterData> passParameterData = gatherer->materialToPassAndParameter().begin().value();
+            const QVector<Qt3DRender::Render::OpenGL::RenderPassParameterData> passParameterData = gatherer->materialToPassAndParameter().begin().value();
             QCOMPARE(passParameterData.size(), 1);
 
-            const Qt3DRender::Render::RenderPassParameterData data = passParameterData.first();
+            const Qt3DRender::Render::OpenGL::RenderPassParameterData data = passParameterData.first();
 
             QCOMPARE(data.parameterInfo.size(), 1);
             QCOMPARE(data.parameterInfo.first().handle, testAspect.nodeManagers()->parameterManager()->lookupHandle(effectParameter->id()));
@@ -724,7 +724,7 @@ private Q_SLOTS:
             material.es2Pass()->addParameter(passParam);
 
             Qt3DRender::TestAspect testAspect(sceneRoot);
-            Qt3DRender::Render::MaterialParameterGathererJobPtr gatherer = testAspect.materialGathererJob();
+            Qt3DRender::Render::OpenGL::MaterialParameterGathererJobPtr gatherer = testAspect.materialGathererJob();
             testAspect.initializeRenderer();
 
             QCOMPARE(testAspect.nodeManagers()->materialManager()->activeHandles().size(), 1);
@@ -741,10 +741,10 @@ private Q_SLOTS:
             // THEN -> TechniqueFilter wins
             QCOMPARE(gatherer->materialToPassAndParameter().size(), 1);
 
-            const QVector<Qt3DRender::Render::RenderPassParameterData> passParameterData = gatherer->materialToPassAndParameter().begin().value();
+            const QVector<Qt3DRender::Render::OpenGL::RenderPassParameterData> passParameterData = gatherer->materialToPassAndParameter().begin().value();
             QCOMPARE(passParameterData.size(), 1);
 
-            const Qt3DRender::Render::RenderPassParameterData data = passParameterData.first();
+            const Qt3DRender::Render::OpenGL::RenderPassParameterData data = passParameterData.first();
 
             QCOMPARE(data.parameterInfo.size(), 1);
             QCOMPARE(data.parameterInfo.first().handle, testAspect.nodeManagers()->parameterManager()->lookupHandle(techniqueParam->id()));
@@ -768,7 +768,7 @@ private Q_SLOTS:
             material.es2Pass()->addParameter(passParam);
 
             Qt3DRender::TestAspect testAspect(sceneRoot);
-            Qt3DRender::Render::MaterialParameterGathererJobPtr gatherer = testAspect.materialGathererJob();
+            Qt3DRender::Render::OpenGL::MaterialParameterGathererJobPtr gatherer = testAspect.materialGathererJob();
             testAspect.initializeRenderer();
 
             QCOMPARE(testAspect.nodeManagers()->materialManager()->activeHandles().size(), 1);
@@ -785,10 +785,10 @@ private Q_SLOTS:
             // THEN -> TechniqueFilter wins
             QCOMPARE(gatherer->materialToPassAndParameter().size(), 1);
 
-            const QVector<Qt3DRender::Render::RenderPassParameterData> passParameterData = gatherer->materialToPassAndParameter().begin().value();
+            const QVector<Qt3DRender::Render::OpenGL::RenderPassParameterData> passParameterData = gatherer->materialToPassAndParameter().begin().value();
             QCOMPARE(passParameterData.size(), 1);
 
-            const Qt3DRender::Render::RenderPassParameterData data = passParameterData.first();
+            const Qt3DRender::Render::OpenGL::RenderPassParameterData data = passParameterData.first();
 
             QCOMPARE(data.parameterInfo.size(), 1);
             QCOMPARE(data.parameterInfo.first().handle, testAspect.nodeManagers()->parameterManager()->lookupHandle(passParam->id()));
diff --git a/tests/auto/render/opengl/qgraphicsutils/tst_qgraphicsutils.cpp b/tests/auto/render/opengl/qgraphicsutils/tst_qgraphicsutils.cpp
index 2e0dd0f96..bd4772045 100644
--- a/tests/auto/render/opengl/qgraphicsutils/tst_qgraphicsutils.cpp
+++ b/tests/auto/render/opengl/qgraphicsutils/tst_qgraphicsutils.cpp
@@ -44,14 +44,14 @@ private slots:
 
 void tst_QGraphicsUtils::fillScalarInDataArray()
 {
-    Qt3DRender::Render::ShaderUniform description;
+    Qt3DRender::Render::OpenGL::ShaderUniform description;
 
     description.m_size = 1;
     description.m_offset = 0;
     description.m_arrayStride = 10;
 
     QVector4D testVector(8.0f, 8.0f, 3.0f, 1.0f);
-    const GLfloat *vectorData = Qt3DRender::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(testVector, 1, 4);
+    const GLfloat *vectorData = Qt3DRender::Render::OpenGL::QGraphicsUtils::valueArrayFromVariant<GLfloat>(testVector, 1, 4);
 
     for (int i = 0; i < 4; i++) {
         if (i == 0)
@@ -68,7 +68,7 @@ void tst_QGraphicsUtils::fillScalarInDataArray()
     char *innerData = data.data();
 
     // Checked that we are not overflowing
-    Qt3DRender::Render::QGraphicsUtils::fillDataArray(innerData, vectorData, description, 2);
+    Qt3DRender::Render::OpenGL::QGraphicsUtils::fillDataArray(innerData, vectorData, description, 2);
     for (int i = 0; i < 4; ++i) {
         if (i < 2)
             QVERIFY(vectorData[i] == ((GLfloat*)innerData)[i]);
@@ -77,7 +77,7 @@ void tst_QGraphicsUtils::fillScalarInDataArray()
     }
 
     // Check that all values are copied
-    Qt3DRender::Render::QGraphicsUtils::fillDataArray(innerData, vectorData, description, 4);
+    Qt3DRender::Render::OpenGL::QGraphicsUtils::fillDataArray(innerData, vectorData, description, 4);
     for (int i = 0; i < 4; ++i)
         QVERIFY(vectorData[i] == ((GLfloat*)innerData)[i]);
 
@@ -86,7 +86,7 @@ void tst_QGraphicsUtils::fillScalarInDataArray()
     data = QByteArray(description.m_size * 8 * sizeof(GLfloat), 0);
     innerData = data.data();
 
-    Qt3DRender::Render::QGraphicsUtils::fillDataArray(innerData, vectorData, description, 4);
+    Qt3DRender::Render::OpenGL::QGraphicsUtils::fillDataArray(innerData, vectorData, description, 4);
     for (int i = 0; i < 8; ++i) {
         if (i < 4)
             QVERIFY(((GLfloat*)innerData)[i] == 0.0f);
@@ -102,9 +102,9 @@ void tst_QGraphicsUtils::fillArray()
     QVector4D testVector3(4.0f, 5.0f, 4.0f, 2.0f);
 
     QVariantList variantList = QVariantList() << testVector << testVector2 << testVector3;
-    const GLfloat *vectorData = Qt3DRender::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(QVariant(variantList), 3, 4);
+    const GLfloat *vectorData = Qt3DRender::Render::OpenGL::QGraphicsUtils::valueArrayFromVariant<GLfloat>(QVariant(variantList), 3, 4);
 
-    Qt3DRender::Render::ShaderUniform description;
+    Qt3DRender::Render::OpenGL::ShaderUniform description;
 
     description.m_size = 3;
     description.m_offset = 16;
@@ -112,7 +112,7 @@ void tst_QGraphicsUtils::fillArray()
 
     QByteArray data(description.m_size * (4 + description.m_arrayStride) * sizeof(GLfloat) + description.m_offset, 0);
     char *innerData = data.data();
-    Qt3DRender::Render::QGraphicsUtils::fillDataArray(innerData, vectorData, description, 4);
+    Qt3DRender::Render::OpenGL::QGraphicsUtils::fillDataArray(innerData, vectorData, description, 4);
 
     int offset = description.m_offset / sizeof(GLfloat);
     int stride = description.m_arrayStride / sizeof(GLfloat);
@@ -144,25 +144,25 @@ void tst_QGraphicsUtils::fillScalarWithOffsets()
     QVector4D color(4.0f, 5.0f, 4.0f, 1.0f);
     float intensity = 1.0f;
 
-    Qt3DRender::Render::ShaderUniform posUniform;
+    Qt3DRender::Render::OpenGL::ShaderUniform posUniform;
     posUniform.m_size = 1;
     posUniform.m_arrayStride = 0;
     posUniform.m_matrixStride = 0;
     posUniform.m_offset = 0;
 
-    Qt3DRender::Render::ShaderUniform dirUniform;
+    Qt3DRender::Render::OpenGL::ShaderUniform dirUniform;
     dirUniform.m_size = 1;
     dirUniform.m_arrayStride = 0;
     dirUniform.m_matrixStride = 0;
     dirUniform.m_offset = 16;
 
-    Qt3DRender::Render::ShaderUniform colUniform;
+    Qt3DRender::Render::OpenGL::ShaderUniform colUniform;
     colUniform.m_size = 1;
     colUniform.m_arrayStride = 0;
     colUniform.m_matrixStride = 0;
     colUniform.m_offset = 32;
 
-    Qt3DRender::Render::ShaderUniform intUniform;
+    Qt3DRender::Render::OpenGL::ShaderUniform intUniform;
     intUniform.m_size = 1;
     intUniform.m_arrayStride = 0;
     intUniform.m_matrixStride = 0;
@@ -171,18 +171,18 @@ void tst_QGraphicsUtils::fillScalarWithOffsets()
     QVector<GLfloat> data(16);
     void *innerData = data.data();
 
-    Qt3DRender::Render::QGraphicsUtils::fillDataArray(innerData,
-                                                Qt3DRender::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(position, 1, 3),
-                                                posUniform, 3);
-    Qt3DRender::Render::QGraphicsUtils::fillDataArray(innerData,
-                                                Qt3DRender::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(direction, 1, 3),
-                                                dirUniform, 3);
-    Qt3DRender::Render::QGraphicsUtils::fillDataArray(innerData,
-                                                Qt3DRender::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(color, 1, 4),
-                                                colUniform, 4);
-    Qt3DRender::Render::QGraphicsUtils::fillDataArray(innerData,
-                                                Qt3DRender::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(intensity, 1, 1),
-                                                intUniform, 1);
+    Qt3DRender::Render::OpenGL::QGraphicsUtils::fillDataArray(innerData,
+                                                              Qt3DRender::Render::OpenGL::QGraphicsUtils::valueArrayFromVariant<GLfloat>(position, 1, 3),
+                                                              posUniform, 3);
+    Qt3DRender::Render::OpenGL::QGraphicsUtils::fillDataArray(innerData,
+                                                              Qt3DRender::Render::OpenGL::QGraphicsUtils::valueArrayFromVariant<GLfloat>(direction, 1, 3),
+                                                              dirUniform, 3);
+    Qt3DRender::Render::OpenGL::QGraphicsUtils::fillDataArray(innerData,
+                                                              Qt3DRender::Render::OpenGL::QGraphicsUtils::valueArrayFromVariant<GLfloat>(color, 1, 4),
+                                                              colUniform, 4);
+    Qt3DRender::Render::OpenGL::QGraphicsUtils::fillDataArray(innerData,
+                                                              Qt3DRender::Render::OpenGL::QGraphicsUtils::valueArrayFromVariant<GLfloat>(intensity, 1, 1),
+                                                              intUniform, 1);
 
     GLfloat *floatData = (GLfloat*)innerData;
 
@@ -214,9 +214,9 @@ void tst_QGraphicsUtils::fillMatrix4x4()
     QMatrix4x4 mat(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f);
 
     // column major
-    const GLfloat *matData = Qt3DRender::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(mat, 1, 16);
+    const GLfloat *matData = Qt3DRender::Render::OpenGL::QGraphicsUtils::valueArrayFromVariant<GLfloat>(mat, 1, 16);
 
-    Qt3DRender::Render::ShaderUniform description;
+    Qt3DRender::Render::OpenGL::ShaderUniform description;
 
     description.m_size = 1;
     description.m_offset = 0;
@@ -226,7 +226,7 @@ void tst_QGraphicsUtils::fillMatrix4x4()
 
     QByteArray data(description.m_size * 16 * sizeof(GLfloat), 0);
     char *innerData = data.data();
-    Qt3DRender::Render::QGraphicsUtils::fillDataMatrixArray(innerData, matData, description, 4, 4);
+    Qt3DRender::Render::OpenGL::QGraphicsUtils::fillDataMatrixArray(innerData, matData, description, 4, 4);
     // Check for no offset/no stride
     for (int i = 0; i < 16; ++i)
         QVERIFY((((GLfloat *)innerData)[i]) == matData[i]);
@@ -234,7 +234,7 @@ void tst_QGraphicsUtils::fillMatrix4x4()
     description.m_offset = 12;
     data = QByteArray((description.m_size * 16  + description.m_offset) * sizeof(GLfloat), 0);
     innerData = data.data();
-    Qt3DRender::Render::QGraphicsUtils::fillDataMatrixArray(innerData, matData, description, 4, 4);
+    Qt3DRender::Render::OpenGL::QGraphicsUtils::fillDataMatrixArray(innerData, matData, description, 4, 4);
     // Check with 12 offset/no stride
     for (int i = 0; i < 16; ++i)
         QVERIFY((((GLfloat *)innerData)[3 + i]) == matData[i]);
@@ -242,7 +242,7 @@ void tst_QGraphicsUtils::fillMatrix4x4()
     description.m_matrixStride = 16;
     data = QByteArray((description.m_size * 16 + 4 * description.m_matrixStride + description.m_offset) * sizeof(GLfloat), 0);
     innerData = data.data();
-    Qt3DRender::Render::QGraphicsUtils::fillDataMatrixArray(innerData, matData, description, 4, 4);
+    Qt3DRender::Render::OpenGL::QGraphicsUtils::fillDataMatrixArray(innerData, matData, description, 4, 4);
     // Check with 10 offset/ 16 stride
     int offset = description.m_offset / sizeof(GLfloat);
     int matrixStride = description.m_matrixStride / sizeof(GLfloat);
@@ -259,9 +259,9 @@ void tst_QGraphicsUtils::fillMatrix3x4()
     QMatrix3x4 mat;
 
     mat.fill(6.0f);
-    const GLfloat *matData = Qt3DRender::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(QVariant::fromValue(mat), 1, 12);
+    const GLfloat *matData = Qt3DRender::Render::OpenGL::QGraphicsUtils::valueArrayFromVariant<GLfloat>(QVariant::fromValue(mat), 1, 12);
 
-    Qt3DRender::Render::ShaderUniform description;
+    Qt3DRender::Render::OpenGL::ShaderUniform description;
 
     description.m_size = 1;
     description.m_offset = 16;
@@ -270,7 +270,7 @@ void tst_QGraphicsUtils::fillMatrix3x4()
 
     QByteArray data((description.m_size * 12 + 3 * description.m_matrixStride + description.m_offset) * sizeof(GLfloat), 0);
     char *innerData = data.data();
-    Qt3DRender::Render::QGraphicsUtils::fillDataMatrixArray(innerData, matData, description, 3, 4);
+    Qt3DRender::Render::OpenGL::QGraphicsUtils::fillDataMatrixArray(innerData, matData, description, 3, 4);
     // Check with 16 offset/ 12 stride
     int offset = description.m_offset / sizeof(GLfloat);
     int matrixStride = description.m_matrixStride / sizeof(GLfloat);
@@ -287,9 +287,9 @@ void tst_QGraphicsUtils::fillMatrix4x3()
     QMatrix4x3 mat;
 
     mat.fill(6.0f);
-    const GLfloat *matData = Qt3DRender::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(QVariant::fromValue(mat), 1, 12);
+    const GLfloat *matData = Qt3DRender::Render::OpenGL::QGraphicsUtils::valueArrayFromVariant<GLfloat>(QVariant::fromValue(mat), 1, 12);
 
-    Qt3DRender::Render::ShaderUniform description;
+    Qt3DRender::Render::OpenGL::ShaderUniform description;
 
     description.m_size = 1;
     description.m_offset = 16;
@@ -298,7 +298,7 @@ void tst_QGraphicsUtils::fillMatrix4x3()
 
     QByteArray data((description.m_size * 12 + 4 * description.m_matrixStride + description.m_offset) * sizeof(GLfloat), 0);
     char *innerData = data.data();
-    Qt3DRender::Render::QGraphicsUtils::fillDataMatrixArray(innerData, matData, description, 4, 3);
+    Qt3DRender::Render::OpenGL::QGraphicsUtils::fillDataMatrixArray(innerData, matData, description, 4, 3);
     // Check with 16 offset/ 16 stride
     int offset = description.m_offset / sizeof(GLfloat);
     int matrixStride = description.m_matrixStride / sizeof(GLfloat);
@@ -321,9 +321,9 @@ void tst_QGraphicsUtils::fillMatrixArray()
 
     QVariantList matrices = QVariantList() << QVariant::fromValue(mat1) << QVariant::fromValue(mat2) << QVariant::fromValue(mat3);
 
-    const GLfloat *matData = Qt3DRender::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(QVariant::fromValue(matrices), 3, 12);
+    const GLfloat *matData = Qt3DRender::Render::OpenGL::QGraphicsUtils::valueArrayFromVariant<GLfloat>(QVariant::fromValue(matrices), 3, 12);
 
-    Qt3DRender::Render::ShaderUniform description;
+    Qt3DRender::Render::OpenGL::ShaderUniform description;
 
     description.m_size = 3;
     description.m_offset = 12;
@@ -332,7 +332,7 @@ void tst_QGraphicsUtils::fillMatrixArray()
 
     QByteArray data((description.m_size * (12 + 4 * description.m_matrixStride + description.m_arrayStride) + description.m_offset) * sizeof(GLfloat), 0);
     char *innerData = data.data();
-    Qt3DRender::Render::QGraphicsUtils::fillDataMatrixArray(innerData, matData, description, 4, 3);
+    Qt3DRender::Render::OpenGL::QGraphicsUtils::fillDataMatrixArray(innerData, matData, description, 4, 3);
     // Check with 12 offset/ 4 array stride / 16 matrix stride
     int offset = description.m_offset / sizeof(GLfloat);
     int matrixStride = description.m_matrixStride / sizeof(GLfloat);
diff --git a/tests/auto/render/opengl/renderer/tst_renderer.cpp b/tests/auto/render/opengl/renderer/tst_renderer.cpp
index 6aed6ed5f..db7a37af1 100644
--- a/tests/auto/render/opengl/renderer/tst_renderer.cpp
+++ b/tests/auto/render/opengl/renderer/tst_renderer.cpp
@@ -50,7 +50,7 @@ private Q_SLOTS:
     {
         // GIVEN
         Qt3DRender::Render::NodeManagers nodeManagers;
-        Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
+        Qt3DRender::Render::OpenGL::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
         Qt3DRender::Render::OffscreenSurfaceHelper offscreenHelper(&renderer);
         Qt3DRender::Render::RenderSettings settings;
         // owned by FG manager
@@ -107,8 +107,8 @@ private Q_SLOTS:
     {
         // GIVEN
         Qt3DRender::Render::NodeManagers nodeManagers;
-        Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
-        Qt3DRender::Render::RenderQueue *renderQueue = renderer.renderQueue();
+        Qt3DRender::Render::OpenGL::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
+        Qt3DRender::Render::OpenGL::RenderQueue *renderQueue = renderer.renderQueue();
         Qt3DRender::Render::OffscreenSurfaceHelper offscreenHelper(&renderer);
         Qt3DRender::Render::RenderSettings settings;
         // owned by FG manager
@@ -129,16 +129,16 @@ private Q_SLOTS:
         // NOTE: FilterCompatibleTechniqueJob and ShaderGathererJob cannot run because the context
         // is not initialized in this test
 
-        const int renderViewBuilderMaterialCacheJobCount = 1 + Qt3DRender::Render::RenderViewBuilder::optimalJobCount();
+        const int renderViewBuilderMaterialCacheJobCount = 1 + Qt3DRender::Render::OpenGL::RenderViewBuilder::optimalJobCount();
         // syncMaterialGathererJob
         // n * materialGathererJob
         const int layerCacheJobCount = 2;
         // filterEntityByLayerJob,
         // syncFilterEntityByLayerJob
 
-        const int singleRenderViewCommandRebuildJobCount  = 1 + Qt3DRender::Render::RenderViewBuilder::optimalJobCount();
+        const int singleRenderViewCommandRebuildJobCount  = 1 + Qt3DRender::Render::OpenGL::RenderViewBuilder::optimalJobCount();
 
-        const int singleRenderViewJobCount = 8 + 1 * Qt3DRender::Render::RenderViewBuilder::optimalJobCount();
+        const int singleRenderViewJobCount = 8 + 1 * Qt3DRender::Render::OpenGL::RenderViewBuilder::optimalJobCount();
         // RenderViewBuilder renderViewJob,
         //                   syncRenderViewInitializationJob,
         //                   syncFrustumCullingJob,
diff --git a/tests/auto/render/opengl/renderqueue/tst_renderqueue.cpp b/tests/auto/render/opengl/renderqueue/tst_renderqueue.cpp
index 2be089495..728648a3c 100644
--- a/tests/auto/render/opengl/renderqueue/tst_renderqueue.cpp
+++ b/tests/auto/render/opengl/renderqueue/tst_renderqueue.cpp
@@ -53,7 +53,7 @@ private Q_SLOTS:
 void tst_RenderQueue::setRenderViewCount()
 {
     // GIVEN
-    Qt3DRender::Render::RenderQueue renderQueue;
+    Qt3DRender::Render::OpenGL::RenderQueue renderQueue;
 
     // THEN
     QCOMPARE(renderQueue.wasReset(), true);
@@ -70,7 +70,7 @@ void tst_RenderQueue::setRenderViewCount()
 void tst_RenderQueue::circleQueues()
 {
     // GIVEN
-    Qt3DRender::Render::RenderQueue renderQueue;
+    Qt3DRender::Render::OpenGL::RenderQueue renderQueue;
     renderQueue.setTargetRenderViewCount(7);
 
     // WHEN
@@ -85,9 +85,9 @@ void tst_RenderQueue::circleQueues()
         QCOMPARE(renderQueue.currentRenderViewCount(), 0);
 
         // WHEN
-        QList<Qt3DRender::Render::RenderView *> renderViews;
+        QList<Qt3DRender::Render::OpenGL::RenderView *> renderViews;
         for (int i = 0; i < 7; i++) {
-            renderViews << new Qt3DRender::Render::RenderView();
+            renderViews << new Qt3DRender::Render::OpenGL::RenderView();
             renderQueue.queueRenderView(renderViews.at(i), i);
         }
 
@@ -99,19 +99,19 @@ void tst_RenderQueue::circleQueues()
 void tst_RenderQueue::checkOrder()
 {
     // GIVEN
-    Qt3DRender::Render::RenderQueue renderQueue;
+    Qt3DRender::Render::OpenGL::RenderQueue renderQueue;
     renderQueue.setTargetRenderViewCount(7);
-    QVector<Qt3DRender::Render::RenderView *> renderViews(7);
+    QVector<Qt3DRender::Render::OpenGL::RenderView *> renderViews(7);
 
     // WHEN
     for (int i = 0; i < 7; ++i) {
         int processingOrder = (i % 2 == 0) ? (6 - i) : i;
-        renderViews[processingOrder] = new Qt3DRender::Render::RenderView();
+        renderViews[processingOrder] = new Qt3DRender::Render::OpenGL::RenderView();
         renderQueue.queueRenderView(renderViews[processingOrder], processingOrder);
     }
 
     // THEN
-    QVector<Qt3DRender::Render::RenderView *> frame = renderQueue.nextFrameQueue();
+    QVector<Qt3DRender::Render::OpenGL::RenderView *> frame = renderQueue.nextFrameQueue();
     for (int i = 0; i < 7; ++i) {
         QVERIFY(frame[i] == renderViews[i]);
     }
@@ -120,14 +120,14 @@ void tst_RenderQueue::checkOrder()
 void tst_RenderQueue::checkTimeToSubmit()
 {
     // GIVEN
-    Qt3DRender::Render::RenderQueue renderQueue;
+    Qt3DRender::Render::OpenGL::RenderQueue renderQueue;
     renderQueue.setTargetRenderViewCount(7);
-    QVector<Qt3DRender::Render::RenderView *> renderViews(7);
+    QVector<Qt3DRender::Render::OpenGL::RenderView *> renderViews(7);
 
     // WHEN
     for (int i = 0; i < 7; i++) {
         int processingOrder = (i % 2 == 0) ? (6 - i) : i;
-        renderViews[processingOrder] = new Qt3DRender::Render::RenderView();
+        renderViews[processingOrder] = new Qt3DRender::Render::OpenGL::RenderView();
         renderQueue.queueRenderView(renderViews[processingOrder], processingOrder);
 
         // THEN
@@ -144,7 +144,7 @@ class SimpleWorker : public QThread
 public:
     QSemaphore m_waitSubmit;
     QSemaphore m_waitQueue;
-    Qt3DRender::Render::RenderQueue *m_renderQueues;
+    Qt3DRender::Render::OpenGL::RenderQueue *m_renderQueues;
 
 public Q_SLOTS:
 
@@ -160,7 +160,7 @@ public Q_SLOTS:
                 // THEN
                 QCOMPARE(m_renderQueues->currentRenderViewCount(), j);
                 // WHEN
-                m_renderQueues->queueRenderView(new Qt3DRender::Render::RenderView(), j);
+                m_renderQueues->queueRenderView(new Qt3DRender::Render::OpenGL::RenderView(), j);
                 // THEN
                 QVERIFY(m_renderQueues->targetRenderViewCount() == 7);
                 QCOMPARE(m_renderQueues->currentRenderViewCount(), j + 1);
@@ -178,7 +178,7 @@ public Q_SLOTS:
 void tst_RenderQueue::concurrentQueueAccess()
 {
     // GIVEN
-    Qt3DRender::Render::RenderQueue *renderQueue = new Qt3DRender::Render::RenderQueue;
+    Qt3DRender::Render::OpenGL::RenderQueue *renderQueue = new Qt3DRender::Render::OpenGL::RenderQueue;
 
     SimpleWorker *jobsThread = new SimpleWorker();
     renderQueue->setTargetRenderViewCount(7);
@@ -212,7 +212,7 @@ void tst_RenderQueue::concurrentQueueAccess()
 void tst_RenderQueue::resetQueue()
 {
     // GIVEN
-    Qt3DRender::Render::RenderQueue renderQueue;
+    Qt3DRender::Render::OpenGL::RenderQueue renderQueue;
 
     for (int j = 0; j < 5; j++) {
         // WHEN
@@ -222,7 +222,7 @@ void tst_RenderQueue::resetQueue()
         QVERIFY(renderQueue.currentRenderViewCount() == 0);
 
         // WHEN
-        QVector<Qt3DRender::Render::RenderView *> renderViews(5);
+        QVector<Qt3DRender::Render::OpenGL::RenderView *> renderViews(5);
         for (int i = 0; i < 5; ++i) {
             renderQueue.queueRenderView(renderViews.at(i), i);
         }
diff --git a/tests/auto/render/opengl/renderviewbuilder/tst_renderviewbuilder.cpp b/tests/auto/render/opengl/renderviewbuilder/tst_renderviewbuilder.cpp
index 6dc463589..fe534e243 100644
--- a/tests/auto/render/opengl/renderviewbuilder/tst_renderviewbuilder.cpp
+++ b/tests/auto/render/opengl/renderviewbuilder/tst_renderviewbuilder.cpp
@@ -96,14 +96,14 @@ public:
         return d_func()->m_renderer->nodeManagers();
     }
 
-    Render::Renderer *renderer() const
+    Render::OpenGL::Renderer *renderer() const
     {
-        return static_cast<Render::Renderer *>(d_func()->m_renderer);
+        return static_cast<Render::OpenGL::Renderer *>(d_func()->m_renderer);
     }
 
-    Render::MaterialParameterGathererJobPtr materialGathererJob() const
+    Render::OpenGL::MaterialParameterGathererJobPtr materialGathererJob() const
     {
-        Render::MaterialParameterGathererJobPtr job = Render::MaterialParameterGathererJobPtr::create();
+        Render::OpenGL::MaterialParameterGathererJobPtr job = Render::OpenGL::MaterialParameterGathererJobPtr::create();
         job->setNodeManagers(nodeManagers());
         return job;
     }
@@ -216,7 +216,7 @@ private Q_SLOTS:
 
         {
             // WHEN
-            Qt3DRender::Render::RenderViewBuilder renderViewBuilder(leafNode, 0, testAspect.renderer());
+            Qt3DRender::Render::OpenGL::RenderViewBuilder renderViewBuilder(leafNode, 0, testAspect.renderer());
 
             // THEN
             QCOMPARE(renderViewBuilder.renderViewIndex(), 0);
@@ -247,14 +247,14 @@ private Q_SLOTS:
             QVERIFY(renderViewBuilder.filterEntityByLayerJob().isNull());
             QVERIFY(renderViewBuilder.syncFilterEntityByLayerJob().isNull());
 
-            QCOMPARE(renderViewBuilder.renderViewCommandUpdaterJobs().size(), Qt3DRender::Render::RenderViewBuilder::optimalJobCount());
+            QCOMPARE(renderViewBuilder.renderViewCommandUpdaterJobs().size(), Qt3DRender::Render::OpenGL::RenderViewBuilder::optimalJobCount());
             QCOMPARE(renderViewBuilder.materialGathererJobs().size(), 0);
-            QCOMPARE(renderViewBuilder.buildJobHierachy().size(), 8 + 1 * Qt3DRender::Render::RenderViewBuilder::optimalJobCount());
+            QCOMPARE(renderViewBuilder.buildJobHierachy().size(), 8 + 1 * Qt3DRender::Render::OpenGL::RenderViewBuilder::optimalJobCount());
         }
 
         {
             // WHEN
-            Qt3DRender::Render::RenderViewBuilder renderViewBuilder(leafNode, 0, testAspect.renderer());
+            Qt3DRender::Render::OpenGL::RenderViewBuilder renderViewBuilder(leafNode, 0, testAspect.renderer());
             renderViewBuilder.setLayerCacheNeedsToBeRebuilt(true);
             renderViewBuilder.prepareJobs();
 
@@ -264,22 +264,22 @@ private Q_SLOTS:
             QVERIFY(!renderViewBuilder.syncFilterEntityByLayerJob().isNull());
 
             // mark jobs dirty and recheck
-            QCOMPARE(renderViewBuilder.buildJobHierachy().size(), 10 + 1 * Qt3DRender::Render::RenderViewBuilder::optimalJobCount());
+            QCOMPARE(renderViewBuilder.buildJobHierachy().size(), 10 + 1 * Qt3DRender::Render::OpenGL::RenderViewBuilder::optimalJobCount());
         }
 
         {
             // WHEN
-            Qt3DRender::Render::RenderViewBuilder renderViewBuilder(leafNode, 0, testAspect.renderer());
+            Qt3DRender::Render::OpenGL::RenderViewBuilder renderViewBuilder(leafNode, 0, testAspect.renderer());
             renderViewBuilder.setMaterialGathererCacheNeedsToBeRebuilt(true);
             renderViewBuilder.prepareJobs();
 
             // THEN
             QCOMPARE(renderViewBuilder.materialGathererCacheNeedsToBeRebuilt(), true);
-            QCOMPARE(renderViewBuilder.materialGathererJobs().size(), Qt3DRender::Render::RenderViewBuilder::optimalJobCount());
+            QCOMPARE(renderViewBuilder.materialGathererJobs().size(), Qt3DRender::Render::OpenGL::RenderViewBuilder::optimalJobCount());
             QVERIFY(!renderViewBuilder.syncMaterialGathererJob().isNull());
 
             // mark jobs dirty and recheck
-            QCOMPARE(renderViewBuilder.buildJobHierachy().size(), 9 + 2 * Qt3DRender::Render::RenderViewBuilder::optimalJobCount());
+            QCOMPARE(renderViewBuilder.buildJobHierachy().size(), 9 + 2 * Qt3DRender::Render::OpenGL::RenderViewBuilder::optimalJobCount());
         }
     }
 
@@ -296,7 +296,7 @@ private Q_SLOTS:
 
         {
             // WHEN
-            Qt3DRender::Render::RenderViewBuilder renderViewBuilder(leafNode, 0, testAspect.renderer());
+            Qt3DRender::Render::OpenGL::RenderViewBuilder renderViewBuilder(leafNode, 0, testAspect.renderer());
             renderViewBuilder.prepareJobs();
             renderViewBuilder.buildJobHierachy();
 
@@ -357,7 +357,7 @@ private Q_SLOTS:
         }
         {
             // WHEN
-            Qt3DRender::Render::RenderViewBuilder renderViewBuilder(leafNode, 0, testAspect.renderer());
+            Qt3DRender::Render::OpenGL::RenderViewBuilder renderViewBuilder(leafNode, 0, testAspect.renderer());
             renderViewBuilder.setLayerCacheNeedsToBeRebuilt(true);
             renderViewBuilder.setMaterialGathererCacheNeedsToBeRebuilt(true);
             renderViewBuilder.prepareJobs();
@@ -441,7 +441,7 @@ private Q_SLOTS:
         QVERIFY(leafNode != nullptr);
 
         // WHEN
-        Qt3DRender::Render::RenderViewBuilder renderViewBuilder(leafNode, 0, testAspect.renderer());
+        Qt3DRender::Render::OpenGL::RenderViewBuilder renderViewBuilder(leafNode, 0, testAspect.renderer());
         renderViewBuilder.prepareJobs();
         renderViewBuilder.buildJobHierachy();
         renderViewBuilder.renderViewJob()->run();
@@ -456,7 +456,7 @@ private Q_SLOTS:
         Qt3DRender::QViewport *viewport = new Qt3DRender::QViewport();
         Qt3DRender::QClearBuffers *clearBuffer = new Qt3DRender::QClearBuffers(viewport);
         Qt3DRender::TestAspect testAspect(buildSimpleScene(viewport));
-        Qt3DRender::Render::Renderer *renderer = testAspect.renderer();
+        Qt3DRender::Render::OpenGL::Renderer *renderer = testAspect.renderer();
 
         // THEN
         Qt3DRender::Render::FrameGraphNode *leafNode = testAspect.nodeManagers()->frameGraphManager()->lookupNode(clearBuffer->id());
@@ -476,7 +476,7 @@ private Q_SLOTS:
         Qt3DRender::QViewport *viewport = new Qt3DRender::QViewport();
         Qt3DRender::QClearBuffers *clearBuffer = new Qt3DRender::QClearBuffers(viewport);
         Qt3DRender::TestAspect testAspect(buildSimpleScene(viewport));
-        Qt3DRender::Render::Renderer *renderer = testAspect.renderer();
+        Qt3DRender::Render::OpenGL::Renderer *renderer = testAspect.renderer();
 
         // THEN
         Qt3DRender::Render::FrameGraphNode *leafNode = testAspect.nodeManagers()->frameGraphManager()->lookupNode(clearBuffer->id());
@@ -495,7 +495,7 @@ private Q_SLOTS:
         Qt3DRender::QViewport *viewport = new Qt3DRender::QViewport();
         Qt3DRender::QClearBuffers *clearBuffer = new Qt3DRender::QClearBuffers(viewport);
         Qt3DRender::TestAspect testAspect(buildSimpleScene(viewport));
-        Qt3DRender::Render::Renderer *renderer = testAspect.renderer();
+        Qt3DRender::Render::OpenGL::Renderer *renderer = testAspect.renderer();
 
         // THEN
         Qt3DRender::Render::FrameGraphNode *leafNode = testAspect.nodeManagers()->frameGraphManager()->lookupNode(clearBuffer->id());
@@ -528,7 +528,7 @@ private Q_SLOTS:
 
         {
             // WHEN
-            Qt3DRender::Render::RenderViewBuilder renderViewBuilder(leafNode, 0, testAspect.renderer());
+            Qt3DRender::Render::OpenGL::RenderViewBuilder renderViewBuilder(leafNode, 0, testAspect.renderer());
             renderViewBuilder.prepareJobs();
             renderViewBuilder.buildJobHierachy();
 
@@ -552,7 +552,7 @@ private Q_SLOTS:
         }
         {
             // WHEN
-            Qt3DRender::Render::RenderViewBuilder renderViewBuilder(leafNode, 0, testAspect.renderer());
+            Qt3DRender::Render::OpenGL::RenderViewBuilder renderViewBuilder(leafNode, 0, testAspect.renderer());
             renderViewBuilder.setLayerCacheNeedsToBeRebuilt(true);
             renderViewBuilder.prepareJobs();
             renderViewBuilder.buildJobHierachy();
@@ -598,7 +598,7 @@ private Q_SLOTS:
         QVERIFY(leafNode != nullptr);
 
         // WHEN
-        Qt3DRender::Render::RenderViewBuilder renderViewBuilder(leafNode, 0, testAspect.renderer());
+        Qt3DRender::Render::OpenGL::RenderViewBuilder renderViewBuilder(leafNode, 0, testAspect.renderer());
         renderViewBuilder.prepareJobs();
         renderViewBuilder.buildJobHierachy();
 
@@ -622,7 +622,7 @@ private Q_SLOTS:
         Qt3DRender::QLayer *layer = new Qt3DRender::QLayer();
         layerFilter->addLayer(layer);
         Qt3DRender::TestAspect testAspect(buildEntityFilterTestScene(viewport, layer));
-        Qt3DRender::Render::Renderer *renderer = testAspect.renderer();
+        Qt3DRender::Render::OpenGL::Renderer *renderer = testAspect.renderer();
 
         // THEN
         Qt3DRender::Render::FrameGraphNode *leafNode = testAspect.nodeManagers()->frameGraphManager()->lookupNode(layerFilter->id());
@@ -631,7 +631,8 @@ private Q_SLOTS:
         // WHEN
         renderer->markDirty(Qt3DRender::Render::AbstractRenderer::AllDirty, nullptr);
 
-        Qt3DRender::Render::RenderViewBuilder renderViewBuilder(leafNode, 0, testAspect.renderer());
+        Qt3DRender::Render::OpenGL::RenderViewBuilder renderViewBuilder(leafNode, 0, testAspect.renderer());
+
         renderViewBuilder.setLayerCacheNeedsToBeRebuilt(true);
         renderViewBuilder.prepareJobs();
         renderViewBuilder.buildJobHierachy();
@@ -653,7 +654,7 @@ private Q_SLOTS:
         std::sort(renderableEntity.begin(), renderableEntity.end());
 
         // WHEN
-        renderableEntity = Qt3DRender::Render::RenderViewBuilder::entitiesInSubset(renderableEntity, filteredEntity);
+        renderableEntity = Qt3DRender::Render::OpenGL::RenderViewBuilder::entitiesInSubset(renderableEntity, filteredEntity);
 
         // THEN
         QCOMPARE(renderableEntity.size(), 100);
diff --git a/tests/auto/render/opengl/renderviews/tst_renderviews.cpp b/tests/auto/render/opengl/renderviews/tst_renderviews.cpp
index d30b8ddca..0b1e22909 100644
--- a/tests/auto/render/opengl/renderviews/tst_renderviews.cpp
+++ b/tests/auto/render/opengl/renderviews/tst_renderviews.cpp
@@ -48,6 +48,8 @@ namespace Qt3DRender {
 
 namespace Render {
 
+namespace OpenGL {
+
 namespace {
 
 void compareShaderParameterPacks(const ShaderParameterPack &t1,
@@ -127,7 +129,7 @@ private Q_SLOTS:
             QCOMPARE(backendBarrier.waitOperations(), barriers);
 
             // WHEN
-            Qt3DRender::Render::setRenderViewConfigFromFrameGraphLeafNode(&renderView, &backendBarrier);
+            Qt3DRender::Render::OpenGL::setRenderViewConfigFromFrameGraphLeafNode(&renderView, &backendBarrier);
 
             // THEN
             QCOMPARE(backendBarrier.waitOperations(), renderView.memoryBarrier());
@@ -139,7 +141,7 @@ private Q_SLOTS:
     {
         // GIVEN
         Qt3DRender::Render::NodeManagers nodeManagers;
-        Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
+        Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
         RenderView renderView;
         QVector<RenderCommand> rawCommands;
         QVector<QSortPolicy::SortType> sortTypes;
@@ -174,7 +176,7 @@ private Q_SLOTS:
     {
         // GIVEN
         Qt3DRender::Render::NodeManagers nodeManagers;
-        Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
+        Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
         RenderView renderView;
         QVector<RenderCommand> rawCommands;
         QVector<QSortPolicy::SortType> sortTypes;
@@ -266,7 +268,7 @@ private Q_SLOTS:
         QFETCH(QVector<ShaderParameterPack>, expectedMinimizedParameters);
 
         Qt3DRender::Render::NodeManagers nodeManagers;
-        Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
+        Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
         renderer.setNodeManagers(&nodeManagers);
 
         GLShaderManager *shaderManager = renderer.glResourceManagers()->glShaderManager();
@@ -312,7 +314,7 @@ private Q_SLOTS:
     {
         // GIVEN
         Qt3DRender::Render::NodeManagers nodeManagers;
-        Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
+        Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
         RenderView renderView;
         QVector<RenderCommand> rawCommands;
         QVector<QSortPolicy::SortType> sortTypes;
@@ -347,7 +349,7 @@ private Q_SLOTS:
     {
         // GIVEN
         Qt3DRender::Render::NodeManagers nodeManagers;
-        Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
+        Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
         RenderView renderView;
         QVector<RenderCommand> rawCommands;
         QVector<QSortPolicy::SortType> sortTypes;
@@ -382,7 +384,7 @@ private Q_SLOTS:
     {
         // GIVEN
         Qt3DRender::Render::NodeManagers nodeManagers;
-        Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
+        Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
         RenderView renderView;
         QVector<RenderCommand> rawCommands;
         QVector<QSortPolicy::SortType> sortTypes;
@@ -542,6 +544,8 @@ private Q_SLOTS:
 private:
 };
 
+} // OpenGL
+
 } // Render
 
 } // Qt3DRender
@@ -549,6 +553,6 @@ private:
 QT_END_NAMESPACE
 
 //APPLESS_
-QTEST_MAIN(Qt3DRender::Render::tst_RenderViews)
+QTEST_MAIN(Qt3DRender::Render::OpenGL::tst_RenderViews)
 
 #include "tst_renderviews.moc"
diff --git a/tests/auto/render/opengl/renderviewutils/tst_renderviewutils.cpp b/tests/auto/render/opengl/renderviewutils/tst_renderviewutils.cpp
index 8a345d840..6b714b9e1 100644
--- a/tests/auto/render/opengl/renderviewutils/tst_renderviewutils.cpp
+++ b/tests/auto/render/opengl/renderviewutils/tst_renderviewutils.cpp
@@ -108,11 +108,11 @@ public:
         return m_scalar;
     }
 
-    QHash<QString, Qt3DRender::Render::ShaderUniform> buildUniformMap(const QString &blockName)
+    QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform> buildUniformMap(const QString &blockName)
     {
-        QHash<QString, Qt3DRender::Render::ShaderUniform> uniforms;
+        QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform> uniforms;
 
-        uniforms.insert(blockName + QStringLiteral(".scalar"), Qt3DRender::Render::ShaderUniform());
+        uniforms.insert(blockName + QStringLiteral(".scalar"), Qt3DRender::Render::OpenGL::ShaderUniform());
 
         return uniforms;
     }
@@ -149,11 +149,11 @@ public:
         return m_texture;
     }
 
-    QHash<QString, Qt3DRender::Render::ShaderUniform> buildUniformMap(const QString &blockName)
+    QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform> buildUniformMap(const QString &blockName)
     {
-        QHash<QString, Qt3DRender::Render::ShaderUniform> uniforms;
+        QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform> uniforms;
 
-        uniforms.insert(blockName + QStringLiteral(".texture"), Qt3DRender::Render::ShaderUniform());
+        uniforms.insert(blockName + QStringLiteral(".texture"), Qt3DRender::Render::OpenGL::ShaderUniform());
 
         return uniforms;
     }
@@ -190,11 +190,11 @@ public:
         return m_array;
     }
 
-    QHash<QString, Qt3DRender::Render::ShaderUniform> buildUniformMap(const QString &blockName)
+    QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform> buildUniformMap(const QString &blockName)
     {
-        QHash<QString, Qt3DRender::Render::ShaderUniform> uniforms;
+        QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform> uniforms;
 
-        uniforms.insert(blockName + QStringLiteral(".array[0]"), Qt3DRender::Render::ShaderUniform());
+        uniforms.insert(blockName + QStringLiteral(".array[0]"), Qt3DRender::Render::OpenGL::ShaderUniform());
 
         return uniforms;
     }
@@ -245,12 +245,12 @@ public:
         return m_array;
     }
 
-    virtual QHash<QString, Qt3DRender::Render::ShaderUniform> buildUniformMap(const QString &blockName)
+    virtual QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform> buildUniformMap(const QString &blockName)
     {
-        QHash<QString, Qt3DRender::Render::ShaderUniform> uniforms;
+        QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform> uniforms;
 
-        uniforms.insert(blockName + QStringLiteral(".scalar"), Qt3DRender::Render::ShaderUniform());
-        uniforms.insert(blockName + QStringLiteral(".array[0]"), Qt3DRender::Render::ShaderUniform());
+        uniforms.insert(blockName + QStringLiteral(".scalar"), Qt3DRender::Render::OpenGL::ShaderUniform());
+        uniforms.insert(blockName + QStringLiteral(".array[0]"), Qt3DRender::Render::OpenGL::ShaderUniform());
 
         return uniforms;
     }
@@ -299,17 +299,17 @@ public:
         return m_inner;
     }
 
-    QHash<QString, Qt3DRender::Render::ShaderUniform> buildUniformMap(const QString &blockName) override
+    QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform> buildUniformMap(const QString &blockName) override
     {
-        QHash<QString, Qt3DRender::Render::ShaderUniform> innerUniforms;
+        QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform> innerUniforms;
 
         StructShaderData *innerData = nullptr;
         if ((innerData = qobject_cast<StructShaderData *>(m_inner)) != nullptr)
             innerUniforms = innerData->buildUniformMap(QStringLiteral(".inner"));
 
-        QHash<QString, Qt3DRender::Render::ShaderUniform> uniforms = StructShaderData::buildUniformMap(blockName);
-        QHash<QString, Qt3DRender::Render::ShaderUniform>::const_iterator it = innerUniforms.begin();
-        const QHash<QString, Qt3DRender::Render::ShaderUniform>::const_iterator end = innerUniforms.end();
+        QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform> uniforms = StructShaderData::buildUniformMap(blockName);
+        QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform>::const_iterator it = innerUniforms.begin();
+        const QHash<QString, Qt3DRender::Render::OpenGL::ShaderUniform>::const_iterator end = innerUniforms.end();
 
         while (it != end) {
             uniforms.insert(blockName + it.key(), it.value());
@@ -362,7 +362,7 @@ void tst_RenderViewUtils::topLevelScalarValueNoUniforms()
     QVERIFY(backendShaderData != nullptr);
 
     // WHEB
-    Qt3DRender::Render::UniformBlockValueBuilder blockBuilder;
+    Qt3DRender::Render::OpenGL::UniformBlockValueBuilder blockBuilder;
     blockBuilder.shaderDataManager = manager.data();
     blockBuilder.textureManager = textureManager.data();
     blockBuilder.updatedPropertiesOnly = false;
@@ -391,7 +391,7 @@ void tst_RenderViewUtils::topLevelScalarValue()
     QVERIFY(backendShaderData != nullptr);
 
     // WHEN
-    Qt3DRender::Render::UniformBlockValueBuilder blockBuilder;
+    Qt3DRender::Render::OpenGL::UniformBlockValueBuilder blockBuilder;
     blockBuilder.shaderDataManager = manager.data();
     blockBuilder.textureManager = textureManager.data();
     blockBuilder.updatedPropertiesOnly = false;
@@ -404,8 +404,8 @@ void tst_RenderViewUtils::topLevelScalarValue()
     QCOMPARE(blockBuilder.activeUniformNamesToValue.count(), 1);
 
     // WHEN
-    Qt3DRender::Render::UniformBlockValueBuilderHash::const_iterator it = blockBuilder.activeUniformNamesToValue.begin();
-    const Qt3DRender::Render::UniformBlockValueBuilderHash::const_iterator end = blockBuilder.activeUniformNamesToValue.end();
+    Qt3DRender::Render::OpenGL::UniformBlockValueBuilderHash::const_iterator it = blockBuilder.activeUniformNamesToValue.begin();
+    const Qt3DRender::Render::OpenGL::UniformBlockValueBuilderHash::const_iterator end = blockBuilder.activeUniformNamesToValue.end();
 
     while (it != end) {
         // THEN
@@ -433,7 +433,7 @@ void tst_RenderViewUtils::topLevelTextureValueNoUniforms()
     QVERIFY(backendShaderData != nullptr);
 
     // WHEB
-    Qt3DRender::Render::UniformBlockValueBuilder blockBuilder;
+    Qt3DRender::Render::OpenGL::UniformBlockValueBuilder blockBuilder;
     blockBuilder.shaderDataManager = manager.data();
     blockBuilder.textureManager = textureManager.data();
     blockBuilder.updatedPropertiesOnly = false;
@@ -464,7 +464,7 @@ void tst_RenderViewUtils::topLevelTextureValue()
     QVERIFY(backendShaderData != nullptr);
 
     // WHEN
-    Qt3DRender::Render::UniformBlockValueBuilder blockBuilder;
+    Qt3DRender::Render::OpenGL::UniformBlockValueBuilder blockBuilder;
     blockBuilder.shaderDataManager = manager.data();
     blockBuilder.textureManager = textureManager.data();
     blockBuilder.updatedPropertiesOnly = false;
@@ -477,8 +477,8 @@ void tst_RenderViewUtils::topLevelTextureValue()
     QCOMPARE(blockBuilder.activeUniformNamesToValue.count(), 1);
 
     // WHEN
-    Qt3DRender::Render::UniformBlockValueBuilderHash::const_iterator it = blockBuilder.activeUniformNamesToValue.begin();
-    const Qt3DRender::Render::UniformBlockValueBuilderHash::const_iterator end = blockBuilder.activeUniformNamesToValue.end();
+    Qt3DRender::Render::OpenGL::UniformBlockValueBuilderHash::const_iterator it = blockBuilder.activeUniformNamesToValue.begin();
+    const Qt3DRender::Render::OpenGL::UniformBlockValueBuilderHash::const_iterator end = blockBuilder.activeUniformNamesToValue.end();
 
     while (it != end) {
         // THEN
@@ -506,7 +506,7 @@ void tst_RenderViewUtils::topLevelArrayValue()
     QVERIFY(backendShaderData != nullptr);
 
     // WHEN
-    Qt3DRender::Render::UniformBlockValueBuilder blockBuilder;
+    Qt3DRender::Render::OpenGL::UniformBlockValueBuilder blockBuilder;
     blockBuilder.shaderDataManager = manager.data();
     blockBuilder.textureManager = textureManager.data();
     blockBuilder.updatedPropertiesOnly = false;
@@ -519,8 +519,8 @@ void tst_RenderViewUtils::topLevelArrayValue()
     QCOMPARE(blockBuilder.activeUniformNamesToValue.count(), 1);
 
     // WHEN
-    Qt3DRender::Render::UniformBlockValueBuilderHash::const_iterator it = blockBuilder.activeUniformNamesToValue.begin();
-    const Qt3DRender::Render::UniformBlockValueBuilderHash::const_iterator end = blockBuilder.activeUniformNamesToValue.end();
+    Qt3DRender::Render::OpenGL::UniformBlockValueBuilderHash::const_iterator it = blockBuilder.activeUniformNamesToValue.begin();
+    const Qt3DRender::Render::OpenGL::UniformBlockValueBuilderHash::const_iterator end = blockBuilder.activeUniformNamesToValue.end();
 
     while (it != end) {
         // THEN
@@ -571,13 +571,13 @@ void tst_RenderViewUtils::nestedShaderDataValue()
     QVERIFY(backendShaderData3 != nullptr);
 
     // WHEN
-    Qt3DRender::Render::UniformBlockValueBuilder blockBuilder;
+    Qt3DRender::Render::OpenGL::UniformBlockValueBuilder blockBuilder;
     blockBuilder.shaderDataManager = manager.data();
     blockBuilder.textureManager = textureManager.data();
     blockBuilder.updatedPropertiesOnly = false;
-    blockBuilder.uniforms.insert(QStringLiteral("MyBlock.array[0].scalar"), Qt3DRender::Render::ShaderUniform());
-    blockBuilder.uniforms.insert(QStringLiteral("MyBlock.array[1].scalar"), Qt3DRender::Render::ShaderUniform());
-    blockBuilder.uniforms.insert(QStringLiteral("MyBlock.array[2].scalar"), Qt3DRender::Render::ShaderUniform());
+    blockBuilder.uniforms.insert(QStringLiteral("MyBlock.array[0].scalar"), Qt3DRender::Render::OpenGL::ShaderUniform());
+    blockBuilder.uniforms.insert(QStringLiteral("MyBlock.array[1].scalar"), Qt3DRender::Render::OpenGL::ShaderUniform());
+    blockBuilder.uniforms.insert(QStringLiteral("MyBlock.array[2].scalar"), Qt3DRender::Render::OpenGL::ShaderUniform());
     // build name-value map
     blockBuilder.buildActiveUniformNameValueMapStructHelper(backendArrayShaderData, QStringLiteral("MyBlock"));
 
@@ -647,7 +647,7 @@ void tst_RenderViewUtils::topLevelStructValue()
     QVERIFY(backendShaderData != nullptr);
 
     // WHEN
-    Qt3DRender::Render::UniformBlockValueBuilder blockBuilder;
+    Qt3DRender::Render::OpenGL::UniformBlockValueBuilder blockBuilder;
     blockBuilder.shaderDataManager = manager.data();
     blockBuilder.textureManager = textureManager.data();
     blockBuilder.updatedPropertiesOnly = false;
@@ -660,8 +660,8 @@ void tst_RenderViewUtils::topLevelStructValue()
     QCOMPARE(blockBuilder.activeUniformNamesToValue.count(), blockBuilder.uniforms.count());
 
     // WHEN
-    Qt3DRender::Render::UniformBlockValueBuilderHash::const_iterator it = blockBuilder.activeUniformNamesToValue.begin();
-    const Qt3DRender::Render::UniformBlockValueBuilderHash::const_iterator end = blockBuilder.activeUniformNamesToValue.end();
+    Qt3DRender::Render::OpenGL::UniformBlockValueBuilderHash::const_iterator it = blockBuilder.activeUniformNamesToValue.begin();
+    const Qt3DRender::Render::OpenGL::UniformBlockValueBuilderHash::const_iterator end = blockBuilder.activeUniformNamesToValue.end();
 
     while (it != end) {
         // THEN
@@ -693,13 +693,13 @@ void tst_RenderViewUtils::topLevelDynamicProperties()
     QVERIFY(backendShaderData != nullptr);
 
     // WHEN
-    Qt3DRender::Render::UniformBlockValueBuilder blockBuilder;
+    Qt3DRender::Render::OpenGL::UniformBlockValueBuilder blockBuilder;
     blockBuilder.shaderDataManager = manager.data();
     blockBuilder.textureManager = textureManager.data();
     blockBuilder.updatedPropertiesOnly = false;
-    blockBuilder.uniforms.insert(QStringLiteral("MyBlock.scalar"), Qt3DRender::Render::ShaderUniform());
-    blockBuilder.uniforms.insert(QStringLiteral("MyBlock.array[0]"), Qt3DRender::Render::ShaderUniform());
-    blockBuilder.uniforms.insert(QStringLiteral("MyBlock.texture"), Qt3DRender::Render::ShaderUniform());
+    blockBuilder.uniforms.insert(QStringLiteral("MyBlock.scalar"), Qt3DRender::Render::OpenGL::ShaderUniform());
+    blockBuilder.uniforms.insert(QStringLiteral("MyBlock.array[0]"), Qt3DRender::Render::OpenGL::ShaderUniform());
+    blockBuilder.uniforms.insert(QStringLiteral("MyBlock.texture"), Qt3DRender::Render::OpenGL::ShaderUniform());
     // build name-value map
     blockBuilder.buildActiveUniformNameValueMapStructHelper(backendShaderData, QStringLiteral("MyBlock"));
 
diff --git a/tests/auto/render/opengl/textures/tst_textures.cpp b/tests/auto/render/opengl/textures/tst_textures.cpp
index 984d49a3e..5343a6fde 100644
--- a/tests/auto/render/opengl/textures/tst_textures.cpp
+++ b/tests/auto/render/opengl/textures/tst_textures.cpp
@@ -222,7 +222,7 @@ private Q_SLOTS:
     {
         QSKIP("Texture Sharing is now disabled");
         QScopedPointer<Qt3DRender::Render::NodeManagers> mgrs(new Qt3DRender::Render::NodeManagers());
-        Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
+        Qt3DRender::Render::OpenGL::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
         renderer.setNodeManagers(mgrs.data());
 
         // GIVEN
@@ -250,7 +250,7 @@ private Q_SLOTS:
     void shouldCreateDifferentGLTexturess()
     {
         QScopedPointer<Qt3DRender::Render::NodeManagers> mgrs(new Qt3DRender::Render::NodeManagers());
-        Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
+        Qt3DRender::Render::OpenGL::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
         renderer.setNodeManagers(mgrs.data());
 
         // GIVEN
@@ -281,7 +281,7 @@ private Q_SLOTS:
                 QVERIFY(renderer.glResourceManagers()->glTextureManager()->lookupResource(backend[i]->peerId()) !=
                         renderer.glResourceManagers()->glTextureManager()->lookupResource(backend[k]->peerId()));
 
-        QVector<Qt3DRender::Render::GLTexture *> glTextures;
+        QVector<Qt3DRender::Render::OpenGL::GLTexture *> glTextures;
         for (Qt3DRender::Render::Texture *t : backend)
             glTextures.push_back(renderer.glResourceManagers()->glTextureManager()->lookupResource(t->peerId()));
 
@@ -306,10 +306,10 @@ private Q_SLOTS:
     void shouldCreateDifferentGLTexturesWhenUsingSharedTextureIds()
     {
         QScopedPointer<Qt3DRender::Render::NodeManagers> mgrs(new Qt3DRender::Render::NodeManagers());
-        Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
+        Qt3DRender::Render::OpenGL::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
         renderer.setNodeManagers(mgrs.data());
 
-        Qt3DRender::Render::GLResourceManagers *glMgrs = renderer.glResourceManagers();
+        Qt3DRender::Render::OpenGL::GLResourceManagers *glMgrs = renderer.glResourceManagers();
 
         // both texture having the same sharedTextureId
         {
@@ -335,8 +335,8 @@ private Q_SLOTS:
             renderer.updateTexture(bt2);
 
             // THEN
-            Qt3DRender::Render::GLTexture *glt1 = glMgrs->glTextureManager()->lookupResource(bt1->peerId());
-            Qt3DRender::Render::GLTexture *glt2 = glMgrs->glTextureManager()->lookupResource(bt2->peerId());
+            Qt3DRender::Render::OpenGL::GLTexture *glt1 = glMgrs->glTextureManager()->lookupResource(bt1->peerId());
+            Qt3DRender::Render::OpenGL::GLTexture *glt2 = glMgrs->glTextureManager()->lookupResource(bt2->peerId());
             QVERIFY(glt1 != glt2);
             QCOMPARE(glt1->sharedTextureId(), bt1->sharedTextureId());
             QCOMPARE(glt2->sharedTextureId(), bt2->sharedTextureId());
@@ -366,8 +366,8 @@ private Q_SLOTS:
             renderer.updateTexture(bt2);
 
             // THEN
-            Qt3DRender::Render::GLTexture *glt1 = glMgrs->glTextureManager()->lookupResource(bt1->peerId());
-            Qt3DRender::Render::GLTexture *glt2 = glMgrs->glTextureManager()->lookupResource(bt2->peerId());
+            Qt3DRender::Render::OpenGL::GLTexture *glt1 = glMgrs->glTextureManager()->lookupResource(bt1->peerId());
+            Qt3DRender::Render::OpenGL::GLTexture *glt2 = glMgrs->glTextureManager()->lookupResource(bt2->peerId());
             QVERIFY(glt1 != glt2);
             QCOMPARE(glt1->sharedTextureId(), bt1->sharedTextureId());
             QCOMPARE(glt2->sharedTextureId(), bt2->sharedTextureId());
@@ -379,7 +379,7 @@ private Q_SLOTS:
     void generatorsShouldCreateSameData()
     {
         QScopedPointer<Qt3DRender::Render::NodeManagers> mgrs(new Qt3DRender::Render::NodeManagers());
-        Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
+        Qt3DRender::Render::OpenGL::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
         renderer.setNodeManagers(mgrs.data());
 
         // GIVEN
@@ -438,7 +438,7 @@ private Q_SLOTS:
     void checkTextureImageCleanupState()
     {
         // GIVEN
-        Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
+        Qt3DRender::Render::OpenGL::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
         TestTextureImage img(1);
         img.setLayer(2);
         img.setMipLevel(3);
@@ -462,7 +462,7 @@ private Q_SLOTS:
     void checkTextureImageInitializeFromPeer()
     {
         // GIVEN
-        Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
+        Qt3DRender::Render::OpenGL::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
         TestTextureImage img(1);
 
         {
@@ -594,7 +594,7 @@ private Q_SLOTS:
     void checkTextureImageProperlyReleaseGenerator()
     {
         QScopedPointer<Qt3DRender::Render::NodeManagers> mgrs(new Qt3DRender::Render::NodeManagers());
-        Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
+        Qt3DRender::Render::OpenGL::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
         Qt3DRender::Render::TextureManager *texMgr = mgrs->textureManager();
         Qt3DRender::Render::TextureImageManager *texImgMgr = mgrs->textureImageManager();
         renderer.setNodeManagers(mgrs.data());
@@ -634,7 +634,7 @@ private Q_SLOTS:
     void checkTextureIsMarkedForDeletion()
     {
         QScopedPointer<Qt3DRender::Render::NodeManagers> mgrs(new Qt3DRender::Render::NodeManagers());
-        Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
+        Qt3DRender::Render::OpenGL::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
         Qt3DRender::Render::TextureManager *texMgr = mgrs->textureManager();
         renderer.setNodeManagers(mgrs.data());
 
@@ -668,7 +668,7 @@ private Q_SLOTS:
     void checkTextureDestructionReconstructionWithinSameLoop()
     {
         QScopedPointer<Qt3DRender::Render::NodeManagers> mgrs(new Qt3DRender::Render::NodeManagers());
-        Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
+        Qt3DRender::Render::OpenGL::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
         Qt3DRender::Render::TextureManager *texMgr = mgrs->textureManager();
         renderer.setNodeManagers(mgrs.data());
 
@@ -707,7 +707,7 @@ private Q_SLOTS:
     {
         // GIVEN
         QScopedPointer<Qt3DRender::Render::NodeManagers> mgrs(new Qt3DRender::Render::NodeManagers());
-        Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
+        Qt3DRender::Render::OpenGL::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
         Qt3DRender::Render::TextureManager *texMgr = mgrs->textureManager();
         Qt3DRender::Render::TextureImageManager *texImgMgr = mgrs->textureImageManager();
         renderer.setNodeManagers(mgrs.data());
diff --git a/tests/benchmarks/render/jobs/tst_bench_jobs.cpp b/tests/benchmarks/render/jobs/tst_bench_jobs.cpp
index 87689e46c..85b5e8c89 100644
--- a/tests/benchmarks/render/jobs/tst_bench_jobs.cpp
+++ b/tests/benchmarks/render/jobs/tst_bench_jobs.cpp
@@ -87,32 +87,32 @@ namespace Qt3DRender {
 
         QVector<Qt3DCore::QAspectJobPtr> worldTransformJob()
         {
-            static_cast<Render::Renderer *>(d_func()->m_renderer)->m_worldTransformJob->setRoot(d_func()->m_renderer->sceneRoot());
-            return QVector<Qt3DCore::QAspectJobPtr>() << static_cast<Render::Renderer *>(d_func()->m_renderer)->m_worldTransformJob;
+            static_cast<Render::OpenGL::Renderer *>(d_func()->m_renderer)->m_worldTransformJob->setRoot(d_func()->m_renderer->sceneRoot());
+            return QVector<Qt3DCore::QAspectJobPtr>() << static_cast<Render::OpenGL::Renderer *>(d_func()->m_renderer)->m_worldTransformJob;
         }
 
         QVector<Qt3DCore::QAspectJobPtr> updateBoundingJob()
         {
-            static_cast<Render::Renderer *>(d_func()->m_renderer)->m_updateWorldBoundingVolumeJob->setManager(d_func()->m_renderer->nodeManagers()->renderNodesManager());
-            return QVector<Qt3DCore::QAspectJobPtr>() << static_cast<Render::Renderer *>(d_func()->m_renderer)->m_updateWorldBoundingVolumeJob;
+            static_cast<Render::OpenGL::Renderer *>(d_func()->m_renderer)->m_updateWorldBoundingVolumeJob->setManager(d_func()->m_renderer->nodeManagers()->renderNodesManager());
+            return QVector<Qt3DCore::QAspectJobPtr>() << static_cast<Render::OpenGL::Renderer *>(d_func()->m_renderer)->m_updateWorldBoundingVolumeJob;
         }
 
         QVector<Qt3DCore::QAspectJobPtr> calculateBoundingVolumeJob()
         {
-            static_cast<Render::Renderer *>(d_func()->m_renderer)->m_calculateBoundingVolumeJob->setRoot(d_func()->m_renderer->sceneRoot());
-            return QVector<Qt3DCore::QAspectJobPtr>() << static_cast<Render::Renderer *>(d_func()->m_renderer)->m_calculateBoundingVolumeJob;
+            static_cast<Render::OpenGL::Renderer *>(d_func()->m_renderer)->m_calculateBoundingVolumeJob->setRoot(d_func()->m_renderer->sceneRoot());
+            return QVector<Qt3DCore::QAspectJobPtr>() << static_cast<Render::OpenGL::Renderer *>(d_func()->m_renderer)->m_calculateBoundingVolumeJob;
         }
 
         QVector<Qt3DCore::QAspectJobPtr> framePreparationJob()
         {
-            static_cast<Render::Renderer *>(d_func()->m_renderer)->m_updateShaderDataTransformJob->setManagers(d_func()->m_renderer->nodeManagers());
-            return QVector<Qt3DCore::QAspectJobPtr>() << static_cast<Render::Renderer *>(d_func()->m_renderer)->m_updateShaderDataTransformJob;
+            static_cast<Render::OpenGL::Renderer *>(d_func()->m_renderer)->m_updateShaderDataTransformJob->setManagers(d_func()->m_renderer->nodeManagers());
+            return QVector<Qt3DCore::QAspectJobPtr>() << static_cast<Render::OpenGL::Renderer *>(d_func()->m_renderer)->m_updateShaderDataTransformJob;
         }
 
         QVector<Qt3DCore::QAspectJobPtr> frameCleanupJob()
         {
-            static_cast<Render::Renderer *>(d_func()->m_renderer)->m_cleanupJob->setRoot(d_func()->m_renderer->sceneRoot());
-            return QVector<Qt3DCore::QAspectJobPtr>() << static_cast<Render::Renderer *>(d_func()->m_renderer)->m_cleanupJob;
+            static_cast<Render::OpenGL::Renderer *>(d_func()->m_renderer)->m_cleanupJob->setRoot(d_func()->m_renderer->sceneRoot());
+            return QVector<Qt3DCore::QAspectJobPtr>() << static_cast<Render::OpenGL::Renderer *>(d_func()->m_renderer)->m_cleanupJob;
         }
 
         QVector<Qt3DCore::QAspectJobPtr> renderBinJobs()
@@ -140,7 +140,7 @@ namespace Qt3DRender {
                 for (const auto &node: nodes)
                     d_func()->createBackendNode(node);
 
-                static_cast<Qt3DRender::Render::Renderer *>(d_func()->m_renderer)->m_renderSceneRoot =
+                static_cast<Qt3DRender::Render::OpenGL::Renderer *>(d_func()->m_renderer)->m_renderSceneRoot =
                         d_func()->m_renderer->nodeManagers()
                         ->lookupResource<Qt3DRender::Render::Entity, Qt3DRender::Render::EntityManager>(root->id());
             }
diff --git a/tests/benchmarks/render/materialparametergathering/tst_bench_materialparametergathering.cpp b/tests/benchmarks/render/materialparametergathering/tst_bench_materialparametergathering.cpp
index 644c4d74c..340bfdda4 100644
--- a/tests/benchmarks/render/materialparametergathering/tst_bench_materialparametergathering.cpp
+++ b/tests/benchmarks/render/materialparametergathering/tst_bench_materialparametergathering.cpp
@@ -90,9 +90,9 @@ public:
         return d_func()->m_renderer->nodeManagers();
     }
 
-    Render::MaterialParameterGathererJobPtr materialGathererJob() const
+    Render::OpenGL::MaterialParameterGathererJobPtr materialGathererJob() const
     {
-        Render::MaterialParameterGathererJobPtr job = Render::MaterialParameterGathererJobPtr::create();
+        Render::OpenGL::MaterialParameterGathererJobPtr job = Render::OpenGL::MaterialParameterGathererJobPtr::create();
         job->setNodeManagers(nodeManagers());
         return job;
     }
@@ -136,7 +136,7 @@ private Q_SLOTS:
         QScopedPointer<Qt3DRender::TestAspect> aspect(new Qt3DRender::TestAspect(buildTestScene(2000)));
 
         // WHEN
-        Qt3DRender::Render::MaterialParameterGathererJobPtr gatheringJob = aspect->materialGathererJob();
+        Qt3DRender::Render::OpenGL::MaterialParameterGathererJobPtr gatheringJob = aspect->materialGathererJob();
         gatheringJob->setHandles(aspect->nodeManagers()->materialManager()->activeHandles());
 
         QBENCHMARK {