Resolve QTransform symbol ambiguity in unity build

Without this fix, when using unity build, qt3d mixes its symbol with
qtbase, ie., `QTransform` in `src/gui/kernel/qinputmethod.h`,
and `src/gui/kernel/qscreen.h`.

Pick-to: 6.5
Task-number: QTBUG-109394
Change-Id: Ibab5c7ec21bed20e1ca3058e586b38598d992b17
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>

7 files changed, 149 insertions, 138 deletions

diff --git a/src/plugins/renderers/opengl/debug/imguirenderer.cpp b/src/plugins/renderers/opengl/debug/imguirenderer.cpp
index 6d52b515d..e2ea3d203 100644
--- a/src/plugins/renderers/opengl/debug/imguirenderer.cpp
+++ b/src/plugins/renderers/opengl/debug/imguirenderer.cpp
@@ -31,10 +31,8 @@
 
 QT_BEGIN_NAMESPACE
 
-using namespace Qt3DRender;
-using namespace Render;
-using namespace Render::Debug;
-using namespace Render::OpenGL;
+namespace Qt3DRR = Qt3DRender::Render;
+namespace Qt3DRRD = Qt3DRR::Debug;
 
 namespace {
 
@@ -66,42 +64,69 @@ namespace {
     int vertexToPrimitiveCount(Qt3DRender::QGeometryRenderer::PrimitiveType primitiveType, int numVertices) {
         int nPrimitives = 0;
         switch (primitiveType) {
-        case QGeometryRenderer::Points:
-        case QGeometryRenderer::LineLoop: nPrimitives += numVertices; break;
-        case QGeometryRenderer::Triangles: nPrimitives += numVertices / 3; break;
-        case QGeometryRenderer::Lines: nPrimitives += numVertices / 2; break;
-        case QGeometryRenderer::TriangleFan:
-        case QGeometryRenderer::TriangleStrip:
-        case QGeometryRenderer::LineStrip: nPrimitives += numVertices - 1; break;
-        case QGeometryRenderer::TrianglesAdjacency: nPrimitives += numVertices / 6; break;
-        case QGeometryRenderer::TriangleStripAdjacency:
-        case QGeometryRenderer::LineStripAdjacency: nPrimitives += numVertices / 2 - 1; break;
-        case QGeometryRenderer::LinesAdjacency: nPrimitives += numVertices / 4; break;
-        case QGeometryRenderer::Patches: nPrimitives += 1;
+        case Qt3DRender::QGeometryRenderer::Points:
+        case Qt3DRender::QGeometryRenderer::LineLoop:
+            nPrimitives += numVertices;
+            break;
+        case Qt3DRender::QGeometryRenderer::Triangles:
+            nPrimitives += numVertices / 3;
+            break;
+        case Qt3DRender::QGeometryRenderer::Lines:
+            nPrimitives += numVertices / 2;
+            break;
+        case Qt3DRender::QGeometryRenderer::TriangleFan:
+        case Qt3DRender::QGeometryRenderer::TriangleStrip:
+        case Qt3DRender::QGeometryRenderer::LineStrip:
+            nPrimitives += numVertices - 1;
+            break;
+        case Qt3DRender::QGeometryRenderer::TrianglesAdjacency:
+            nPrimitives += numVertices / 6;
+            break;
+        case Qt3DRender::QGeometryRenderer::TriangleStripAdjacency:
+        case Qt3DRender::QGeometryRenderer::LineStripAdjacency:
+            nPrimitives += numVertices / 2 - 1;
+            break;
+        case Qt3DRender::QGeometryRenderer::LinesAdjacency:
+            nPrimitives += numVertices / 4;
+            break;
+        case Qt3DRender::QGeometryRenderer::Patches:
+            nPrimitives += 1;
         }
         return nPrimitives;
     }
 
     const char *primitiveTypeName(Qt3DRender::QGeometryRenderer::PrimitiveType primitiveType) {
         switch (primitiveType) {
-        case QGeometryRenderer::Points: return "Points";
-        case QGeometryRenderer::LineLoop: return "LineLoop";
-        case QGeometryRenderer::Triangles: return "Triangles";
-        case QGeometryRenderer::TrianglesAdjacency: return "TriangleAdjacency";
-        case QGeometryRenderer::TriangleFan: return "TriangleFan";
-        case QGeometryRenderer::TriangleStrip: return "TriangleStrip";
-        case QGeometryRenderer::TriangleStripAdjacency: return "TriangleStringAdjacency";
-        case QGeometryRenderer::LineStrip: return "LineStrip";
-        case QGeometryRenderer::LineStripAdjacency: return "LineStripAdjacency";
-        case QGeometryRenderer::Lines: return "Lines";
-        case QGeometryRenderer::LinesAdjacency: return "LinesAdjacency";
-        case QGeometryRenderer::Patches: return "Patches";
+        case Qt3DRender::QGeometryRenderer::Points:
+            return "Points";
+        case Qt3DRender::QGeometryRenderer::LineLoop:
+            return "LineLoop";
+        case Qt3DRender::QGeometryRenderer::Triangles:
+            return "Triangles";
+        case Qt3DRender::QGeometryRenderer::TrianglesAdjacency:
+            return "TriangleAdjacency";
+        case Qt3DRender::QGeometryRenderer::TriangleFan:
+            return "TriangleFan";
+        case Qt3DRender::QGeometryRenderer::TriangleStrip:
+            return "TriangleStrip";
+        case Qt3DRender::QGeometryRenderer::TriangleStripAdjacency:
+            return "TriangleStringAdjacency";
+        case Qt3DRender::QGeometryRenderer::LineStrip:
+            return "LineStrip";
+        case Qt3DRender::QGeometryRenderer::LineStripAdjacency:
+            return "LineStripAdjacency";
+        case Qt3DRender::QGeometryRenderer::Lines:
+            return "Lines";
+        case Qt3DRender::QGeometryRenderer::LinesAdjacency:
+            return "LinesAdjacency";
+        case Qt3DRender::QGeometryRenderer::Patches:
+            return "Patches";
         }
         return "";
     }
 }
 
-ImGuiRenderer::ImGuiRenderer(Qt3DRender::Render::OpenGL::Renderer *renderer)
+Qt3DRRD::ImGuiRenderer::ImGuiRenderer(Qt3DRR::OpenGL::Renderer *renderer)
     : m_renderer(renderer)
 {
     ImGui::CreateContext();
@@ -128,9 +153,9 @@ ImGuiRenderer::ImGuiRenderer(Qt3DRender::Render::OpenGL::Renderer *renderer)
     m_jobsRange.first = m_jobsRange.second = 0.f;
 }
 
-ImGuiRenderer::~ImGuiRenderer() = default;
+Qt3DRRD::ImGuiRenderer::~ImGuiRenderer() = default;
 
-void ImGuiRenderer::renderDebugOverlay(const std::vector<RenderView *> &renderViews, const RenderView *renderView, int jobsInLastFrame)
+void Qt3DRRD::ImGuiRenderer::renderDebugOverlay(const std::vector<Qt3DRR::OpenGL::RenderView *> &renderViews, const Qt3DRR::OpenGL::RenderView *renderView, int jobsInLastFrame)
 {
     if (!newFrame(renderView))
         return;
@@ -168,10 +193,10 @@ void ImGuiRenderer::renderDebugOverlay(const std::vector<RenderView *> &renderVi
         QSet<HGeometryRenderer> inUseGeometries;
         QSet<Qt3DCore::QNodeId> inUseTextures;
         for (int j=0; j<renderViewsCount; j++) {
-            RenderView *rv = renderViews.at(j);
+            Qt3DRR::OpenGL::RenderView *rv = renderViews.at(j);
             nCommands += rv->commandCount();
-            rv->forEachCommand([&] (const RenderCommand &command) {
-                if (command.m_type != RenderCommand::Draw)
+            rv->forEachCommand([&](const Qt3DRR::OpenGL::RenderCommand &command) {
+                if (command.m_type != Qt3DRR::OpenGL::RenderCommand::Draw)
                     return;
                 nVertices += command.m_primitiveCount;
                 nPrimitives += vertexToPrimitiveCount(command.m_primitiveType, command.m_primitiveCount);
@@ -276,24 +301,24 @@ void ImGuiRenderer::renderDebugOverlay(const std::vector<RenderView *> &renderVi
     renderDrawList(ImGui::GetDrawData());
 }
 
-void ImGuiRenderer::setCapabilities(const QString &capabilities)
+void Qt3DRRD::ImGuiRenderer::setCapabilities(const QString &capabilities)
 {
     m_capabilities = capabilities.toLatin1();
 }
 
-void ImGuiRenderer::showGLInfo()
+void Qt3DRRD::ImGuiRenderer::showGLInfo()
 {
     ImGui::Begin("Open GL Details", &m_showGLInfoWindow);
     ImGui::Text("%s", m_capabilities.data());
     ImGui::End();
 }
 
-void ImGuiRenderer::showRenderDetails(const std::vector<RenderView *> &renderViews)
+void Qt3DRRD::ImGuiRenderer::showRenderDetails(const std::vector<Qt3DRR::OpenGL::RenderView *> &renderViews)
 {
     ImGui::Begin("Render Views", &m_showRenderDetailsWindow);
 
     int i = 1;
-    for (const RenderView *view: renderViews) {
+    for (const Qt3DRR::OpenGL::RenderView *view : renderViews) {
         QString label(QLatin1String("View ") + QString::number(i++));
         if (ImGui::TreeNode(label.toLatin1().data())) {
             ImGui::Text("Viewport: (%.1f, %.1f, %.1f, %.1f)", view->viewport().x(), view->viewport().y(),
@@ -307,7 +332,7 @@ void ImGuiRenderer::showRenderDetails(const std::vector<RenderView *> &renderVie
             ImGui::Text("Clear Stencil Value: %d", view->clearStencilValue());
             int j = 1;
 
-            view->forEachCommand([&] (const RenderCommand &command) {
+            view->forEachCommand([&](const Qt3DRR::OpenGL::RenderCommand &command) {
                 GeometryRenderer *rGeometryRenderer = m_renderer->nodeManagers()->data<GeometryRenderer, GeometryRendererManager>(command.m_geometryRenderer);
                 QString label = QString(QLatin1String("Command %1 {%2}")).arg(QString::number(j++), QString::number(rGeometryRenderer->peerId().id()));
                 if (ImGui::TreeNode(label.toLatin1().data())) {
@@ -330,7 +355,7 @@ void ImGuiRenderer::showRenderDetails(const std::vector<RenderView *> &renderVie
     ImGui::End();
 }
 
-void ImGuiRenderer::renderDrawList(ImDrawData *draw_data)
+void Qt3DRRD::ImGuiRenderer::renderDrawList(ImDrawData *draw_data)
 {
     // Avoid rendering when minimized, scale coordinates for retina displays (screen coordinates != framebuffer coordinates)
     ImGuiIO& io = ImGui::GetIO();
@@ -427,7 +452,7 @@ void ImGuiRenderer::renderDrawList(ImDrawData *draw_data)
     m_funcs->glScissor(last_scissor_box[0], last_scissor_box[1], static_cast<GLsizei>(last_scissor_box[2]), static_cast<GLsizei>(last_scissor_box[3]));
 }
 
-bool ImGuiRenderer::createFontsTexture()
+bool Qt3DRRD::ImGuiRenderer::createFontsTexture()
 {
     // Build texture atlas
     ImGuiIO& io = ImGui::GetIO();
@@ -453,7 +478,7 @@ bool ImGuiRenderer::createFontsTexture()
     return true;
 }
 
-bool ImGuiRenderer::createDeviceObjects()
+bool Qt3DRRD::ImGuiRenderer::createDeviceObjects()
 {
     auto *glContext = m_renderer->submissionContext()->openGLContext();
     if (glContext->format().majorVersion() < 3) {
@@ -571,7 +596,7 @@ bool ImGuiRenderer::createDeviceObjects()
     return true;
 }
 
-bool ImGuiRenderer::newFrame(const RenderView *renderView)
+bool Qt3DRRD::ImGuiRenderer::newFrame(const Qt3DRR::OpenGL::RenderView *renderView)
 {
     if (!m_funcs)
         m_funcs = m_renderer->submissionContext()->openGLContext()->extraFunctions();
@@ -607,7 +632,7 @@ bool ImGuiRenderer::newFrame(const RenderView *renderView)
     return true;
 }
 
-void ImGuiRenderer::onMouseChange(QMouseEvent *event)
+void Qt3DRRD::ImGuiRenderer::onMouseChange(QMouseEvent *event)
 {
     ImGuiIO& io = ImGui::GetIO();
     io.MousePos = ImVec2(event->pos().x(), event->pos().y());
@@ -616,14 +641,14 @@ void ImGuiRenderer::onMouseChange(QMouseEvent *event)
     m_mousePressed[2] = event->buttons() & Qt::MiddleButton;
 }
 
-void ImGuiRenderer::onWheel(QWheelEvent *event)
+void Qt3DRRD::ImGuiRenderer::onWheel(QWheelEvent *event)
 {
     // 5 lines per unit
     m_mouseWheelH += event->pixelDelta().x() / (ImGui::GetTextLineHeight());
     m_mouseWheel += event->pixelDelta().y() / (5.f * ImGui::GetTextLineHeight());
 }
 
-void ImGuiRenderer::onKeyPressRelease(QKeyEvent *event)
+void Qt3DRRD::ImGuiRenderer::onKeyPressRelease(QKeyEvent *event)
 {
     ImGuiIO& io = ImGui::GetIO();
     if (keyMap.contains(event->key()))
@@ -648,7 +673,7 @@ void ImGuiRenderer::onKeyPressRelease(QKeyEvent *event)
 #endif
 }
 
-void ImGuiRenderer::processEvent(QEvent *event)
+void Qt3DRRD::ImGuiRenderer::processEvent(QEvent *event)
 {
     switch (event->type()) {
     case QEvent::MouseMove:
diff --git a/src/plugins/renderers/opengl/graphicshelpers/submissioncontext.cpp b/src/plugins/renderers/opengl/graphicshelpers/submissioncontext.cpp
index 814667c10..6b2536501 100644
--- a/src/plugins/renderers/opengl/graphicshelpers/submissioncontext.cpp
+++ b/src/plugins/renderers/opengl/graphicshelpers/submissioncontext.cpp
@@ -61,8 +61,6 @@ QT_BEGIN_NAMESPACE
 #define GL_DRAW_FRAMEBUFFER 0x8CA9
 #endif
 
-using namespace Qt3DCore;
-
 namespace Qt3DRender {
 namespace Render {
 namespace OpenGL {
@@ -83,14 +81,14 @@ unsigned int nextFreeContextId()
 
 namespace {
 
-GLBuffer::Type attributeTypeToGLBufferType(QAttribute::AttributeType type)
+GLBuffer::Type attributeTypeToGLBufferType(Qt3DCore::QAttribute::AttributeType type)
 {
     switch (type) {
-    case QAttribute::VertexAttribute:
+    case Qt3DCore::QAttribute::VertexAttribute:
         return GLBuffer::ArrayBuffer;
-    case QAttribute::IndexAttribute:
+    case Qt3DCore::QAttribute::IndexAttribute:
         return GLBuffer::IndexBuffer;
-    case QAttribute::DrawIndirectAttribute:
+    case Qt3DCore::QAttribute::DrawIndirectAttribute:
         return GLBuffer::DrawIndirectBuffer;
     default:
         Q_UNREACHABLE();
diff --git a/src/plugins/renderers/opengl/renderer/renderer.cpp b/src/plugins/renderers/opengl/renderer/renderer.cpp
index e9a2ffe48..f7a9e8b6d 100644
--- a/src/plugins/renderers/opengl/renderer/renderer.cpp
+++ b/src/plugins/renderers/opengl/renderer/renderer.cpp
@@ -90,8 +90,6 @@
 
 QT_BEGIN_NAMESPACE
 
-using namespace Qt3DCore;
-
 namespace Qt3DRender {
 namespace Render {
 namespace OpenGL {
@@ -322,7 +320,7 @@ void Renderer::setNodeManagers(NodeManagers *managers)
     m_computableEntityFilterJob->setManager(m_nodesManager->renderNodesManager());
 }
 
-void Renderer::setServices(QServiceLocator *services)
+void Renderer::setServices(Qt3DCore::QServiceLocator *services)
 {
     m_services = services;
 
@@ -678,12 +676,12 @@ void Renderer::render(bool swapBuffers)
 
     // RenderQueue is complete (but that means it may be of size 0)
     if (!queueIsEmpty) {
-        QTaskLogger submissionStatsPart1(m_services->systemInformation(),
-                                         {JobTypes::FrameSubmissionPart1, 0},
-                                         QTaskLogger::Submission);
-        QTaskLogger submissionStatsPart2(m_services->systemInformation(),
-                                         {JobTypes::FrameSubmissionPart2, 0},
-                                         QTaskLogger::Submission);
+        Qt3DCore::QTaskLogger submissionStatsPart1(m_services->systemInformation(),
+                                                   { JobTypes::FrameSubmissionPart1, 0 },
+                                                   Qt3DCore::QTaskLogger::Submission);
+        Qt3DCore::QTaskLogger submissionStatsPart2(m_services->systemInformation(),
+                                                   { JobTypes::FrameSubmissionPart2, 0 },
+                                                   Qt3DCore::QTaskLogger::Submission);
         { // Scoped to destroy surfaceLock
             QSurface *surface = nullptr;
             for (const RenderView *rv: renderViews) {
@@ -979,10 +977,10 @@ void Renderer::lookForDirtyTextures()
     const std::vector<HTexture> &activeTextureHandles = textureManager->activeHandles();
     for (const HTexture &handle: activeTextureHandles) {
         Texture *texture = textureManager->data(handle);
-        const QNodeIdVector imageIds = texture->textureImageIds();
+        const Qt3DCore::QNodeIdVector imageIds = texture->textureImageIds();
 
         // Does the texture reference any of the dirty texture images?
-        for (const QNodeId &imageId: imageIds) {
+        for (const Qt3DCore::QNodeId &imageId : imageIds) {
             if (dirtyImageIds.contains(imageId)) {
                 texture->addDirtyFlag(Texture::DirtyImageGenerators);
                 break;
@@ -1010,7 +1008,7 @@ void Renderer::reloadDirtyShaders()
         // If api of the renderer matches the one from the technique
         if (technique->isCompatibleWithRenderer()) {
             const auto passIds = technique->renderPasses();
-            for (const QNodeId &passId : passIds) {
+            for (const Qt3DCore::QNodeId &passId : passIds) {
                 RenderPass *renderPass = m_nodesManager->renderPassManager()->lookupResource(passId);
                 HShader shaderHandle = m_nodesManager->shaderManager()->lookupHandle(renderPass->shaderProgram());
                 Shader *shader = m_nodesManager->shaderManager()->data(shaderHandle);
@@ -1073,7 +1071,7 @@ void Renderer::sendShaderChangesToFrontend(Qt3DCore::QAspectManager *manager)
             // the time needed to destroy the GLShader assoicated with it.
             if (!frontend)
                 continue;
-            QShaderProgramPrivate *dFrontend = static_cast<decltype(dFrontend)>(QNodePrivate::get(frontend));
+            QShaderProgramPrivate *dFrontend = static_cast<decltype(dFrontend)>(Qt3DCore::QNodePrivate::get(frontend));
             s->unsetRequiresFrontendSync();
             dFrontend->setStatus(s->status());
             dFrontend->setLog(s->log());
@@ -1084,7 +1082,7 @@ void Renderer::sendShaderChangesToFrontend(Qt3DCore::QAspectManager *manager)
     const std::vector<ShaderBuilderUpdate> shaderBuilderUpdates = Qt3DCore::moveAndClear(m_shaderBuilderUpdates);
     for (const ShaderBuilderUpdate &update : shaderBuilderUpdates) {
         QShaderProgramBuilder *builder = static_cast<decltype(builder)>(manager->lookupNode(update.builderId));
-        QShaderProgramBuilderPrivate *dBuilder = static_cast<decltype(dBuilder)>(QNodePrivate::get(builder));
+        QShaderProgramBuilderPrivate *dBuilder = static_cast<decltype(dBuilder)>(Qt3DCore::QNodePrivate::get(builder));
         dBuilder->setShaderCode(update.shaderCode, update.shaderType);
     }
 }
@@ -1116,7 +1114,7 @@ void Renderer::sendTextureChangesToFrontend(Qt3DCore::QAspectManager *manager)
            texture->setFormat(properties.format);
            texture->blockNotifications(blocked);
 
-           QAbstractTexturePrivate *dTexture = static_cast<QAbstractTexturePrivate *>(QNodePrivate::get(texture));
+           QAbstractTexturePrivate *dTexture = static_cast<QAbstractTexturePrivate *>(Qt3DCore::QNodePrivate::get(texture));
 
            dTexture->setStatus(properties.status);
            dTexture->setHandleType(pair.first.handleType);
@@ -1135,7 +1133,7 @@ void Renderer::sendSetFenceHandlesToFrontend(Qt3DCore::QAspectManager *manager)
         if (fgNode != nullptr) { // Node could have been deleted before we got a chance to notify it
             Q_ASSERT(fgNode->nodeType() == FrameGraphNode::SetFence);
             QSetFence *frontend = static_cast<decltype(frontend)>(manager->lookupNode(fgNode->peerId()));
-            QSetFencePrivate *dFrontend = static_cast<decltype(dFrontend)>(QNodePrivate::get(frontend));
+            QSetFencePrivate *dFrontend = static_cast<decltype(dFrontend)>(Qt3DCore::QNodePrivate::get(frontend));
             dFrontend->setHandleType(QSetFence::OpenGLFenceId);
             dFrontend->setHandle(QVariant::fromValue(pair.second));
         }
@@ -1267,7 +1265,7 @@ void Renderer::updateGLResources()
         // We want to upload textures data at this point as the SubmissionThread and
         // AspectThread are locked ensuring no races between Texture/TextureImage and
         // GLTexture
-        QNodeIdVector updatedTexturesForFrame;
+        Qt3DCore::QNodeIdVector updatedTexturesForFrame;
         if (m_submissionContext != nullptr) {
             GLTextureManager *glTextureManager = m_glResourceManagers->glTextureManager();
             const std::vector<HGLTexture> &glTextureHandles = glTextureManager->activeHandles();
@@ -1281,7 +1279,7 @@ void Renderer::updateGLResources()
                 // GLTexture creation provides us width/height/format ... information
                 // for textures which had not initially specified these information (TargetAutomatic...)
                 // Gather these information and store them to be distributed by a change next frame
-                const QNodeIdVector referenceTextureIds = { glTextureManager->texNodeIdForGLTexture.value(glTexture) };
+                const Qt3DCore::QNodeIdVector referenceTextureIds = { glTextureManager->texNodeIdForGLTexture.value(glTexture) };
                 // Store properties and referenceTextureIds
                 if (info.wasUpdated) {
                     Texture::TextureUpdateInfo updateInfo;
@@ -1307,7 +1305,7 @@ void Renderer::updateGLResources()
 
     // Remove destroyed FBOs
     {
-        const QNodeIdVector destroyedRenderTargetIds = m_nodesManager->renderTargetManager()->takeRenderTargetIdsToCleanup();
+        const Qt3DCore::QNodeIdVector destroyedRenderTargetIds = m_nodesManager->renderTargetManager()->takeRenderTargetIdsToCleanup();
         for (const Qt3DCore::QNodeId &renderTargetId : destroyedRenderTargetIds)
             m_submissionContext->releaseRenderTarget(renderTargetId);
     }
@@ -1349,11 +1347,11 @@ void Renderer::updateTexture(Texture *texture)
 
     // Will make the texture requestUpload
     if (dirtyFlags.testFlag(Texture::DirtyImageGenerators)) {
-        const QNodeIdVector textureImageIds = texture->textureImageIds();
+        const Qt3DCore::QNodeIdVector textureImageIds = texture->textureImageIds();
         std::vector<GLTexture::Image> images;
         images.reserve(textureImageIds.size());
         // TODO: Move this into GLTexture directly
-        for (const QNodeId &textureImageId : textureImageIds) {
+        for (const Qt3DCore::QNodeId &textureImageId : textureImageIds) {
             const TextureImage *img = m_nodesManager->textureImageManager()->lookupResource(textureImageId);
             if (img == nullptr) {
                 qWarning() << Q_FUNC_INFO << "invalid TextureImage handle";
@@ -1609,7 +1607,7 @@ Renderer::ViewSubmissionResultData Renderer::submitRenderViews(const std::vector
             Render::RenderCapture *renderCapture =
                     static_cast<Render::RenderCapture*>(m_nodesManager->frameGraphManager()->lookupNode(renderView->renderCaptureNodeId()));
             renderCapture->addRenderCapture(request.captureId, image);
-            const QNodeId renderCaptureId = renderView->renderCaptureNodeId();
+            const Qt3DCore::QNodeId renderCaptureId = renderView->renderCaptureNodeId();
             QMutexLocker lock(&m_pendingRenderCaptureSendRequestsMutex);
             if (!Qt3DCore::contains(m_pendingRenderCaptureSendRequests, renderCaptureId))
                 m_pendingRenderCaptureSendRequests.push_back(renderView->renderCaptureNodeId());
@@ -1621,8 +1619,8 @@ Renderer::ViewSubmissionResultData Renderer::submitRenderViews(const std::vector
         // Perform BlitFramebuffer operations
         if (renderView->hasBlitFramebufferInfo()) {
             const auto &blitFramebufferInfo = renderView->blitFrameBufferInfo();
-            const QNodeId inputTargetId = blitFramebufferInfo.sourceRenderTargetId;
-            const QNodeId outputTargetId = blitFramebufferInfo.destinationRenderTargetId;
+            const Qt3DCore::QNodeId inputTargetId = blitFramebufferInfo.sourceRenderTargetId;
+            const Qt3DCore::QNodeId outputTargetId = blitFramebufferInfo.destinationRenderTargetId;
             const QRect inputRect = blitFramebufferInfo.sourceRect;
             const QRect outputRect = blitFramebufferInfo.destinationRect;
             const QRenderTargetOutput::AttachmentPoint inputAttachmentPoint = blitFramebufferInfo.sourceAttachmentPoint;
@@ -1761,7 +1759,7 @@ bool Renderer::processKeyEvent(QObject *object, QKeyEvent *event)
 }
 
 // Jobs we may have to run even if no rendering will happen
-std::vector<QAspectJobPtr> Renderer::preRenderingJobs()
+std::vector<Qt3DCore::QAspectJobPtr> Renderer::preRenderingJobs()
 {
     if (m_sendBufferCaptureJob->hasRequests())
         return {m_sendBufferCaptureJob};
@@ -1774,10 +1772,10 @@ std::vector<QAspectJobPtr> Renderer::preRenderingJobs()
 // for the rendering of the scene
 std::vector<Qt3DCore::QAspectJobPtr> Renderer::renderBinJobs()
 {
-    std::vector<QAspectJobPtr> renderBinJobs;
+    std::vector<Qt3DCore::QAspectJobPtr> renderBinJobs;
 
     // Remove previous dependencies
-    m_cleanupJob->removeDependency(QWeakPointer<QAspectJob>());
+    m_cleanupJob->removeDependency(QWeakPointer<Qt3DCore::QAspectJob>());
 
     const bool dirtyParametersForCurrentFrame = m_dirtyBits.marked & AbstractRenderer::ParameterDirty;
     const BackendNodeDirtySet dirtyBitsForFrame = m_dirtyBits.marked | m_dirtyBits.remaining;
@@ -1848,7 +1846,7 @@ std::vector<Qt3DCore::QAspectJobPtr> Renderer::renderBinJobs()
             m_updatedDisableSubtreeEnablers.push_back(node->peerId());
     }
 
-    int idealThreadCount = QAspectJobManager::idealThreadCount();
+    int idealThreadCount = Qt3DCore::QAspectJobManager::idealThreadCount();
 
     const size_t fgBranchCount = m_frameGraphLeaves.size();
     if (fgBranchCount > 1) {
@@ -1903,7 +1901,7 @@ std::vector<Qt3DCore::QAspectJobPtr> Renderer::renderBinJobs()
     return renderBinJobs;
 }
 
-QAbstractFrameAdvanceService *Renderer::frameAdvanceService() const
+Qt3DCore::QAbstractFrameAdvanceService *Renderer::frameAdvanceService() const
 {
     return static_cast<Qt3DCore::QAbstractFrameAdvanceService *>(m_vsyncFrameAdvanceService.data());
 }
@@ -2139,7 +2137,7 @@ bool Renderer::updateVAOWithAttributes(Geometry *geometry,
     m_dirtyAttributes.reserve(m_dirtyAttributes.size() + geometry->attributes().size());
     const auto attributeIds = geometry->attributes();
 
-    for (QNodeId attributeId : attributeIds) {
+    for (Qt3DCore::QNodeId attributeId : attributeIds) {
         // TO DO: Improvement we could store handles and use the non locking policy on the attributeManager
         Attribute *attribute = m_nodesManager->attributeManager()->lookupResource(attributeId);
 
@@ -2155,7 +2153,7 @@ bool Renderer::updateVAOWithAttributes(Geometry *geometry,
 
         // Index Attribute
         bool attributeWasDirty = false;
-        if (attribute->attributeType() == QAttribute::IndexAttribute) {
+        if (attribute->attributeType() == Qt3DCore::QAttribute::IndexAttribute) {
             if ((attributeWasDirty = attribute->isDirty()) == true || forceUpdate)
                 m_submissionContext->specifyIndices(buffer);
             // Vertex Attribute
@@ -2196,16 +2194,14 @@ bool Renderer::requiresVAOAttributeUpdate(Geometry *geometry,
 {
     const auto attributeIds = geometry->attributes();
 
-    for (QNodeId attributeId : attributeIds) {
+    for (Qt3DCore::QNodeId attributeId : attributeIds) {
         // TO DO: Improvement we could store handles and use the non locking policy on the attributeManager
         Attribute *attribute = m_nodesManager->attributeManager()->lookupResource(attributeId);
 
         if (attribute == nullptr)
             continue;
 
-        if ((attribute->attributeType() == QAttribute::IndexAttribute && attribute->isDirty()) ||
-                (Qt3DCore::contains(command->m_activeAttributes, attribute->nameId()) &&
-                 attribute->isDirty()))
+        if ((attribute->attributeType() == Qt3DCore::QAttribute::IndexAttribute && attribute->isDirty()) || (Qt3DCore::contains(command->m_activeAttributes, attribute->nameId()) && attribute->isDirty()))
             return true;
     }
     return false;
diff --git a/src/plugins/renderers/opengl/textures/gltexture.cpp b/src/plugins/renderers/opengl/textures/gltexture.cpp
index 7d63fa552..7f358b0e3 100644
--- a/src/plugins/renderers/opengl/textures/gltexture.cpp
+++ b/src/plugins/renderers/opengl/textures/gltexture.cpp
@@ -28,8 +28,6 @@
 
 QT_BEGIN_NAMESPACE
 
-using namespace Qt3DCore;
-
 namespace Qt3DRender {
 namespace Render {
 namespace OpenGL {
diff --git a/src/plugins/renderers/rhi/graphicshelpers/submissioncontext.cpp b/src/plugins/renderers/rhi/graphicshelpers/submissioncontext.cpp
index 384d5665e..53d36922c 100644
--- a/src/plugins/renderers/rhi/graphicshelpers/submissioncontext.cpp
+++ b/src/plugins/renderers/rhi/graphicshelpers/submissioncontext.cpp
@@ -62,8 +62,6 @@
 
 QT_BEGIN_NAMESPACE
 
-using namespace Qt3DCore;
-
 namespace Qt3DRender {
 namespace Render {
 namespace Rhi {
diff --git a/src/plugins/renderers/rhi/renderer/renderer.cpp b/src/plugins/renderers/rhi/renderer/renderer.cpp
index 45485a6c7..95c40ac07 100644
--- a/src/plugins/renderers/rhi/renderer/renderer.cpp
+++ b/src/plugins/renderers/rhi/renderer/renderer.cpp
@@ -93,8 +93,6 @@
 
 QT_BEGIN_NAMESPACE
 
-using namespace Qt3DCore;
-
 namespace Qt3DRender {
 namespace Render {
 namespace Rhi {
@@ -336,7 +334,7 @@ void Renderer::setNodeManagers(NodeManagers *managers)
     m_computableEntityFilterJob->setManager(m_nodesManager->renderNodesManager());
 }
 
-void Renderer::setServices(QServiceLocator *services)
+void Renderer::setServices(Qt3DCore::QServiceLocator *services)
 {
     m_services = services;
 
@@ -613,12 +611,12 @@ void Renderer::render(bool swapBuffers)
 
     // RenderQueue is complete (but that means it may be of size 0)
     if (!queueIsEmpty) {
-        QTaskLogger submissionStatsPart1(m_services->systemInformation(),
-                                         { JobTypes::FrameSubmissionPart1, 0 },
-                                         QTaskLogger::Submission);
-        QTaskLogger submissionStatsPart2(m_services->systemInformation(),
-                                         { JobTypes::FrameSubmissionPart2, 0 },
-                                         QTaskLogger::Submission);
+        Qt3DCore::QTaskLogger submissionStatsPart1(m_services->systemInformation(),
+                                                   { JobTypes::FrameSubmissionPart1, 0 },
+                                                   Qt3DCore::QTaskLogger::Submission);
+        Qt3DCore::QTaskLogger submissionStatsPart2(m_services->systemInformation(),
+                                                   { JobTypes::FrameSubmissionPart2, 0 },
+                                                   Qt3DCore::QTaskLogger::Submission);
 
         std::vector<RHIPassInfo> rhiPassesInfo;
 
@@ -759,8 +757,8 @@ QSurfaceFormat Renderer::format()
 namespace {
 std::optional<QRhiVertexInputAttribute::Format> rhiAttributeType(Attribute *attr) {
     switch (attr->vertexBaseType()) {
-    case QAttribute::Byte:
-    case QAttribute::UnsignedByte: {
+    case Qt3DCore::QAttribute::Byte:
+    case Qt3DCore::QAttribute::UnsignedByte: {
         if (attr->vertexSize() == 1)
             return QRhiVertexInputAttribute::UNormByte;
         if (attr->vertexSize() == 2)
@@ -769,7 +767,7 @@ std::optional<QRhiVertexInputAttribute::Format> rhiAttributeType(Attribute *attr
             return QRhiVertexInputAttribute::UNormByte4;
         break;
     }
-    case QAttribute::UnsignedInt: {
+    case Qt3DCore::QAttribute::UnsignedInt: {
         if (attr->vertexSize() == 1)
             return QRhiVertexInputAttribute::UInt;
         if (attr->vertexSize() == 2)
@@ -780,7 +778,7 @@ std::optional<QRhiVertexInputAttribute::Format> rhiAttributeType(Attribute *attr
             return QRhiVertexInputAttribute::UInt4;
         break;
     }
-    case QAttribute::Float: {
+    case Qt3DCore::QAttribute::Float: {
         if (attr->vertexSize() == 1)
             return QRhiVertexInputAttribute::Float;
         if (attr->vertexSize() == 2)
@@ -1442,10 +1440,10 @@ void Renderer::lookForDirtyTextures()
     const std::vector<HTexture> &activeTextureHandles = textureManager->activeHandles();
     for (const HTexture &handle : activeTextureHandles) {
         Texture *texture = textureManager->data(handle);
-        const QNodeIdVector imageIds = texture->textureImageIds();
+        const Qt3DCore::QNodeIdVector imageIds = texture->textureImageIds();
 
         // Does the texture reference any of the dirty texture images?
-        for (const QNodeId &imageId : imageIds) {
+        for (const Qt3DCore::QNodeId &imageId : imageIds) {
             if (dirtyImageIds.contains(imageId)) {
                 texture->addDirtyFlag(Texture::DirtyImageGenerators);
                 break;
@@ -1475,7 +1473,7 @@ void Renderer::reloadDirtyShaders()
         // If api of the renderer matches the one from the technique
         if (technique->isCompatibleWithRenderer()) {
             const auto passIds = technique->renderPasses();
-            for (const QNodeId &passId : passIds) {
+            for (const Qt3DCore::QNodeId &passId : passIds) {
                 RenderPass *renderPass =
                         m_nodesManager->renderPassManager()->lookupResource(passId);
                 HShader shaderHandle =
@@ -1536,7 +1534,7 @@ void Renderer::sendShaderChangesToFrontend(Qt3DCore::QAspectManager *manager)
                     static_cast<decltype(frontend)>(manager->lookupNode(s->peerId()));
             if (frontend) {
                 QShaderProgramPrivate *dFrontend =
-                        static_cast<decltype(dFrontend)>(QNodePrivate::get(frontend));
+                        static_cast<decltype(dFrontend)>(Qt3DCore::QNodePrivate::get(frontend));
                 dFrontend->setStatus(s->status());
                 dFrontend->setLog(s->log());
                 s->unsetRequiresFrontendSync();
@@ -1552,7 +1550,7 @@ void Renderer::sendShaderChangesToFrontend(Qt3DCore::QAspectManager *manager)
             continue;
 
         QShaderProgramBuilderPrivate *dBuilder =
-                static_cast<decltype(dBuilder)>(QNodePrivate::get(builder));
+                static_cast<decltype(dBuilder)>(Qt3DCore::QNodePrivate::get(builder));
         dBuilder->setShaderCode(update.shaderCode, update.shaderType);
     }
     m_shaderBuilderUpdates.clear();
@@ -1588,7 +1586,7 @@ void Renderer::sendTextureChangesToFrontend(Qt3DCore::QAspectManager *manager)
             texture->blockNotifications(blocked);
 
             QAbstractTexturePrivate *dTexture =
-                    static_cast<QAbstractTexturePrivate *>(QNodePrivate::get(texture));
+                    static_cast<QAbstractTexturePrivate *>(Qt3DCore::QNodePrivate::get(texture));
             dTexture->setStatus(properties.status);
             dTexture->setHandleType(pair.first.handleType);
             dTexture->setHandle(pair.first.handle);
@@ -1648,7 +1646,7 @@ bool Renderer::prepareGeometryInputBindings(const Geometry *geometry, const RHIS
 
     for (Qt3DCore::QNodeId attribute_id : attributesIds) {
         Attribute *attrib = m_nodesManager->attributeManager()->lookupResource(attribute_id);
-        if (attrib->attributeType() != QAttribute::VertexAttribute)
+        if (attrib->attributeType() != Qt3DCore::QAttribute::VertexAttribute)
             continue;
         const int location = locationForAttribute(attrib, shader);
         // In case the shader doesn't use the attribute, we would get no
@@ -1662,20 +1660,20 @@ bool Renderer::prepareGeometryInputBindings(const Geometry *geometry, const RHIS
                 ? QRhiVertexInputBinding::PerInstance
                 : QRhiVertexInputBinding::PerVertex;
 
-        auto getAttributeByteSize = [] (const QAttribute::VertexBaseType type) {
+        auto getAttributeByteSize = [](const Qt3DCore::QAttribute::VertexBaseType type) {
             switch (type) {
-            case QAttribute::Byte:
-            case QAttribute::UnsignedByte:
+            case Qt3DCore::QAttribute::Byte:
+            case Qt3DCore::QAttribute::UnsignedByte:
                 return 1;
-            case QAttribute::Short:
-            case QAttribute::UnsignedShort:
-            case QAttribute::HalfFloat:
+            case Qt3DCore::QAttribute::Short:
+            case Qt3DCore::QAttribute::UnsignedShort:
+            case Qt3DCore::QAttribute::HalfFloat:
                 return 2;
-            case QAttribute::Int:
-            case QAttribute::UnsignedInt:
-            case QAttribute::Float:
+            case Qt3DCore::QAttribute::Int:
+            case Qt3DCore::QAttribute::UnsignedInt:
+            case Qt3DCore::QAttribute::Float:
                 return 4;
-            case QAttribute::Double:
+            case Qt3DCore::QAttribute::Double:
                 return 8;
             }
             return 0;
@@ -1842,7 +1840,7 @@ void Renderer::updateResources()
                     // for textures which had not initially specified these information
                     // (TargetAutomatic...) Gather these information and store them to be distributed by
                     // a change next frame
-                    const QNodeIdVector referenceTextureIds = { rhiTextureManager->texNodeIdForRHITexture.value(rhiTexture) };
+                    const Qt3DCore::QNodeIdVector referenceTextureIds = { rhiTextureManager->texNodeIdForRHITexture.value(rhiTexture) };
                     // Store properties and referenceTextureIds
                     Texture::TextureUpdateInfo updateInfo;
                     updateInfo.properties = info.properties;
@@ -1964,11 +1962,11 @@ void Renderer::updateTexture(Texture *texture)
 
     // Will make the texture requestUpload
     if (dirtyFlags.testFlag(Texture::DirtyImageGenerators)) {
-        const QNodeIdVector textureImageIds = texture->textureImageIds();
+        const Qt3DCore::QNodeIdVector textureImageIds = texture->textureImageIds();
         std::vector<RHITexture::Image> images;
         images.reserve(textureImageIds.size());
         // TODO: Move this into RHITexture directly
-        for (const QNodeId &textureImageId : textureImageIds) {
+        for (const Qt3DCore::QNodeId &textureImageId : textureImageIds) {
             const TextureImage *img =
                     m_nodesManager->textureImageManager()->lookupResource(textureImageId);
             if (img == nullptr) {
@@ -2224,7 +2222,7 @@ bool Renderer::processKeyEvent(QObject *object, QKeyEvent *event)
 }
 
 // Jobs we may have to run even if no rendering will happen
-std::vector<QAspectJobPtr> Renderer::preRenderingJobs()
+std::vector<Qt3DCore::QAspectJobPtr> Renderer::preRenderingJobs()
 {
     if (m_sendBufferCaptureJob->hasRequests())
         return { m_sendBufferCaptureJob };
@@ -2238,10 +2236,10 @@ std::vector<QAspectJobPtr> Renderer::preRenderingJobs()
 // for the rendering of the scene
 std::vector<Qt3DCore::QAspectJobPtr> Renderer::renderBinJobs()
 {
-    std::vector<QAspectJobPtr> renderBinJobs;
+    std::vector<Qt3DCore::QAspectJobPtr> renderBinJobs;
 
     // Remove previous dependencies
-    m_cleanupJob->removeDependency(QWeakPointer<QAspectJob>());
+    m_cleanupJob->removeDependency(QWeakPointer<Qt3DCore::QAspectJob>());
 
     const bool dirtyParametersForCurrentFrame = m_dirtyBits.marked & AbstractRenderer::ParameterDirty;
     const BackendNodeDirtySet dirtyBitsForFrame = m_dirtyBits.marked | m_dirtyBits.remaining;
@@ -2315,7 +2313,7 @@ std::vector<Qt3DCore::QAspectJobPtr> Renderer::renderBinJobs()
                 m_updatedDisableSubtreeEnablers.push_back(node->peerId());
         }
 
-        int idealThreadCount = QAspectJobManager::idealThreadCount();
+        int idealThreadCount = Qt3DCore::QAspectJobManager::idealThreadCount();
 
         const size_t fgBranchCount = m_frameGraphLeaves.size();
         if (fgBranchCount > 1) {
@@ -2379,7 +2377,7 @@ std::vector<Qt3DCore::QAspectJobPtr> Renderer::renderBinJobs()
     return renderBinJobs;
 }
 
-QAbstractFrameAdvanceService *Renderer::frameAdvanceService() const
+Qt3DCore::QAbstractFrameAdvanceService *Renderer::frameAdvanceService() const
 {
     return static_cast<Qt3DCore::QAbstractFrameAdvanceService *>(m_vsyncFrameAdvanceService.data());
 }
@@ -2404,12 +2402,12 @@ bool Renderer::performCompute(QRhiCommandBuffer *cb, RenderCommand &command)
     return true;
 }
 
-static auto rhiIndexFormat(QAttribute::VertexBaseType type)
+static auto rhiIndexFormat(Qt3DCore::QAttribute::VertexBaseType type)
 {
     switch (type) {
-    case QAttribute::VertexBaseType ::UnsignedShort:
+    case Qt3DCore::QAttribute::VertexBaseType ::UnsignedShort:
         return QRhiCommandBuffer::IndexUInt16;
-    case QAttribute::VertexBaseType ::UnsignedInt:
+    case Qt3DCore::QAttribute::VertexBaseType ::UnsignedInt:
         return QRhiCommandBuffer::IndexUInt32;
     default:
         std::abort();
@@ -2481,7 +2479,7 @@ bool Renderer::uploadBuffersForCommand(RHIGraphicsPipeline* graphicsPipeline, Re
         Buffer *buffer = m_nodesManager->bufferManager()->lookupResource(attrib->bufferId());
         RHIBuffer *hbuf = m_RHIResourceManagers->rhiBufferManager()->lookupResource(buffer->peerId());
         switch (attrib->attributeType()) {
-        case QAttribute::VertexAttribute: {
+        case Qt3DCore::QAttribute::VertexAttribute: {
             if (!hbuf->bind(&*m_submissionContext, RHIBuffer::Type((int)RHIBuffer::Type::ArrayBuffer | (int)RHIBuffer::Type::ShaderStorageBuffer)))
                 return false;
             assert(hbuf->rhiBuffer());
@@ -2494,7 +2492,7 @@ bool Renderer::uploadBuffersForCommand(RHIGraphicsPipeline* graphicsPipeline, Re
                 command.vertex_input[bindingIndex] = { hbuf->rhiBuffer(), 0 };
             break;
         }
-        case QAttribute::IndexAttribute: {
+        case Qt3DCore::QAttribute::IndexAttribute: {
             if (!hbuf->bind(&*m_submissionContext, RHIBuffer::Type::IndexBuffer))
                 return false;
             assert(hbuf->rhiBuffer());
@@ -2503,7 +2501,7 @@ bool Renderer::uploadBuffersForCommand(RHIGraphicsPipeline* graphicsPipeline, Re
             command.indexAttribute = attrib;
             break;
         }
-        case QAttribute::DrawIndirectAttribute:
+        case Qt3DCore::QAttribute::DrawIndirectAttribute:
             RHI_UNIMPLEMENTED;
             break;
         }
diff --git a/src/plugins/renderers/rhi/textures/texture.cpp b/src/plugins/renderers/rhi/textures/texture.cpp
index 6bbfb1d13..c216cefdc 100644
--- a/src/plugins/renderers/rhi/textures/texture.cpp
+++ b/src/plugins/renderers/rhi/textures/texture.cpp
@@ -19,8 +19,6 @@
 
 QT_BEGIN_NAMESPACE
 
-using namespace Qt3DCore;
-
 namespace Qt3DRender {
 namespace Render {
 namespace Rhi {