QBackendNode::peerUuid() renamed to peerId()

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

26 files changed, 100 insertions, 100 deletions

diff --git a/src/core/aspects/qabstractaspect.cpp b/src/core/aspects/qabstractaspect.cpp
index c83eb3c76..7f605ff20 100644
--- a/src/core/aspects/qabstractaspect.cpp
+++ b/src/core/aspects/qabstractaspect.cpp
@@ -149,9 +149,9 @@ QBackendNode *QAbstractAspectPrivate::createBackendNode(QNode *frontend) const
         // TO DO: Find a way to specify the changes to observe
         // Register backendNode with QChangeArbiter
         if (m_arbiter != Q_NULLPTR) { // Unit tests may not have the arbiter registered
-            m_arbiter->registerObserver(backendPriv, backend->peerUuid(), AllChanges);
+            m_arbiter->registerObserver(backendPriv, backend->peerId(), AllChanges);
             if (backend->mode() == QBackendNode::ReadWrite)
-                m_arbiter->scene()->addObservable(backendPriv, backend->peerUuid());
+                m_arbiter->scene()->addObservable(backendPriv, backend->peerId());
         }
         return backend;
     }
@@ -171,9 +171,9 @@ void QAbstractAspectPrivate::clearBackendNode(QNode *frontend) const
         QBackendNode *backend = functor->get(frontend->id());
         if (backend != Q_NULLPTR) {
             QBackendNodePrivate *backendPriv = QBackendNodePrivate::get(backend);
-            m_arbiter->unregisterObserver(backendPriv, backend->peerUuid());
+            m_arbiter->unregisterObserver(backendPriv, backend->peerId());
             if (backend->mode() == QBackendNode::ReadWrite)
-                m_arbiter->scene()->removeObservable(backendPriv, backend->peerUuid());
+                m_arbiter->scene()->removeObservable(backendPriv, backend->peerId());
             functor->destroy(frontend->id());
         }
     }
diff --git a/src/core/nodes/qbackendnode.cpp b/src/core/nodes/qbackendnode.cpp
index b7529f42b..8dfc646ce 100644
--- a/src/core/nodes/qbackendnode.cpp
+++ b/src/core/nodes/qbackendnode.cpp
@@ -93,17 +93,17 @@ QBackendNode::~QBackendNode()
 void QBackendNode::setPeer(QNode *peer)
 {
     Q_D(QBackendNode);
-    QNodeId peerUuid;
+    QNodeId peerId;
     if (peer != Q_NULLPTR)
-        peerUuid = peer->id();
-    d->m_peerUuid = peerUuid;
+        peerId = peer->id();
+    d->m_peerId = peerId;
     updateFromPeer(peer);
 }
 
-QNodeId QBackendNode::peerUuid() const Q_DECL_NOEXCEPT
+QNodeId QBackendNode::peerId() const Q_DECL_NOEXCEPT
 {
     Q_D(const QBackendNode);
-    return d->m_peerUuid;
+    return d->m_peerId;
 }
 
 QBackendNode::Mode QBackendNode::mode() const Q_DECL_NOEXCEPT
diff --git a/src/core/nodes/qbackendnode.h b/src/core/nodes/qbackendnode.h
index f85b4ffd4..492935190 100644
--- a/src/core/nodes/qbackendnode.h
+++ b/src/core/nodes/qbackendnode.h
@@ -75,7 +75,7 @@ public:
     virtual ~QBackendNode();
 
     void setPeer(QNode *peer);
-    QNodeId peerUuid() const Q_DECL_NOEXCEPT;
+    QNodeId peerId() const Q_DECL_NOEXCEPT;
 
     Mode mode() const Q_DECL_NOEXCEPT;
     virtual void updateFromPeer(QNode *peer) = 0;
diff --git a/src/core/nodes/qbackendnode_p.h b/src/core/nodes/qbackendnode_p.h
index 4b42f2720..8ab8d4271 100644
--- a/src/core/nodes/qbackendnode_p.h
+++ b/src/core/nodes/qbackendnode_p.h
@@ -81,7 +81,7 @@ public:
     QBackendNode::Mode m_mode;
 
     QLockableObserverInterface *m_arbiter;
-    QNodeId m_peerUuid;
+    QNodeId m_peerId;
 };
 
 } // Qt3D
diff --git a/src/input/backend/action.cpp b/src/input/backend/action.cpp
index 77045f398..f7b048552 100644
--- a/src/input/backend/action.cpp
+++ b/src/input/backend/action.cpp
@@ -77,8 +77,8 @@ void Action::setActionTriggered(bool actionTriggered)
         m_actionTriggered = actionTriggered;
 
         // Send change to the frontend
-        Qt3DCore::QBackendScenePropertyChangePtr e(new Qt3DCore::QBackendScenePropertyChange(Qt3DCore::NodeUpdated, peerUuid()));
-        e->setTargetNode(peerUuid());
+        Qt3DCore::QBackendScenePropertyChangePtr e(new Qt3DCore::QBackendScenePropertyChange(Qt3DCore::NodeUpdated, peerId()));
+        e->setTargetNode(peerId());
         e->setPropertyName("active");
         e->setValue(m_actionTriggered);
         notifyObservers(e);
diff --git a/src/input/backend/assignkeyboardfocusjob.cpp b/src/input/backend/assignkeyboardfocusjob.cpp
index b1fed1bdb..84380aca1 100644
--- a/src/input/backend/assignkeyboardfocusjob.cpp
+++ b/src/input/backend/assignkeyboardfocusjob.cpp
@@ -66,10 +66,10 @@ void AssignKeyboardFocusJob::run()
     Q_FOREACH (const HKeyboardHandler handle, controller->keyboardInputsHandles()) {
         KeyboardHandler *input = m_inputHandler->keyboardInputManager()->data(handle);
         if (input) {
-            bool hasFocus = input->peerUuid() == controller->lastKeyboardInputRequester();
+            bool hasFocus = input->peerId() == controller->lastKeyboardInputRequester();
             input->setFocus(hasFocus);
             if (hasFocus)
-                controller->setCurrentFocusItem(input->peerUuid());
+                controller->setCurrentFocusItem(input->peerId());
         }
     }
 }
diff --git a/src/input/backend/axis.cpp b/src/input/backend/axis.cpp
index 6ab34fc25..7e33eef01 100644
--- a/src/input/backend/axis.cpp
+++ b/src/input/backend/axis.cpp
@@ -77,8 +77,8 @@ void Axis::setAxisValue(float axisValue)
         m_axisValue = axisValue;
 
         // Send a change to the frontend
-        Qt3DCore::QBackendScenePropertyChangePtr e(new Qt3DCore::QBackendScenePropertyChange(Qt3DCore::NodeUpdated, peerUuid()));
-        e->setTargetNode(peerUuid());
+        Qt3DCore::QBackendScenePropertyChangePtr e(new Qt3DCore::QBackendScenePropertyChange(Qt3DCore::NodeUpdated, peerId()));
+        e->setTargetNode(peerId());
         e->setPropertyName("value");
         e->setValue(m_axisValue);
         notifyObservers(e);
diff --git a/src/input/backend/inputhandler.cpp b/src/input/backend/inputhandler.cpp
index 1556256cd..2b8b29924 100644
--- a/src/input/backend/inputhandler.cpp
+++ b/src/input/backend/inputhandler.cpp
@@ -182,7 +182,7 @@ QVector<Qt3DCore::QAspectJobPtr> InputHandler::keyboardJobs()
             controller->updateKeyEvents(events);
             QAspectJobPtr focusChangeJob;
             if (controller->lastKeyboardInputRequester() != controller->currentFocusItem()) {
-                AssignKeyboardFocusJob *job = new AssignKeyboardFocusJob(controller->peerUuid());
+                AssignKeyboardFocusJob *job = new AssignKeyboardFocusJob(controller->peerId());
                 job->setInputHandler(this);
                 focusChangeJob.reset(job);
                 jobs.append(focusChangeJob);
diff --git a/src/input/backend/inputsettings.cpp b/src/input/backend/inputsettings.cpp
index 868a27fd0..838ed7326 100644
--- a/src/input/backend/inputsettings.cpp
+++ b/src/input/backend/inputsettings.cpp
@@ -91,7 +91,7 @@ Qt3DCore::QBackendNode *InputSettingsFunctor::create(Qt3DCore::QNode *frontend)
 Qt3DCore::QBackendNode *InputSettingsFunctor::get(Qt3DCore::QNodeId id) const
 {
     InputSettings *settings = m_handler->inputSettings();
-    if (settings != Q_NULLPTR && settings->peerUuid() == id)
+    if (settings != Q_NULLPTR && settings->peerId() == id)
         return settings;
     return Q_NULLPTR;
 }
@@ -99,7 +99,7 @@ Qt3DCore::QBackendNode *InputSettingsFunctor::get(Qt3DCore::QNodeId id) const
 void InputSettingsFunctor::destroy(Qt3DCore::QNodeId id) const
 {
     InputSettings *settings = m_handler->inputSettings();
-    if (settings != Q_NULLPTR && settings->peerUuid() == id) {
+    if (settings != Q_NULLPTR && settings->peerId() == id) {
         m_handler->setInputSettings(Q_NULLPTR);
         delete settings;
     }
diff --git a/src/input/backend/keyboardhandler.cpp b/src/input/backend/keyboardhandler.cpp
index 4afad30b2..3292a13fa 100644
--- a/src/input/backend/keyboardhandler.cpp
+++ b/src/input/backend/keyboardhandler.cpp
@@ -87,8 +87,8 @@ void KeyboardHandler::setFocus(bool focus)
 {
     if (focus != m_focus) {
         m_focus = focus;
-        QBackendScenePropertyChangePtr e(new QBackendScenePropertyChange(NodeUpdated, peerUuid()));
-        e->setTargetNode(peerUuid());
+        QBackendScenePropertyChangePtr e(new QBackendScenePropertyChange(NodeUpdated, peerId()));
+        e->setTargetNode(peerId());
         e->setPropertyName("focus");
         e->setValue(m_focus);
         notifyObservers(e);
@@ -97,8 +97,8 @@ void KeyboardHandler::setFocus(bool focus)
 
 void KeyboardHandler::keyEvent(const QKeyEventPtr &event)
 {
-    QBackendScenePropertyChangePtr e(new QBackendScenePropertyChange(NodeUpdated, peerUuid()));
-    e->setTargetNode(peerUuid());
+    QBackendScenePropertyChangePtr e(new QBackendScenePropertyChange(NodeUpdated, peerId()));
+    e->setTargetNode(peerId());
     e->setPropertyName("event");
     e->setValue(QVariant::fromValue(event));
     notifyObservers(e);
@@ -129,7 +129,7 @@ void KeyboardHandler::requestFocus()
 {
     KeyboardController *controller = m_inputHandler->keyboardControllerManager()->lookupResource(m_keyboardController);
     if (controller && m_enabled)
-        controller->requestFocusForInput(peerUuid());
+        controller->requestFocusForInput(peerId());
 }
 
 void KeyboardHandler::setController(QNodeId controller)
@@ -137,13 +137,13 @@ void KeyboardHandler::setController(QNodeId controller)
     if (!m_keyboardController.isNull()) {
         KeyboardController *controller =  m_inputHandler->keyboardControllerManager()->lookupResource(m_keyboardController);
         if (controller)
-            controller->removeKeyboardInput(peerUuid());
+            controller->removeKeyboardInput(peerId());
     }
     m_keyboardController = controller;
     if (!m_keyboardController.isNull()) {
         KeyboardController *controller =  m_inputHandler->keyboardControllerManager()->lookupResource(m_keyboardController);
         if (controller)
-            controller->addKeyboardInput(peerUuid());
+            controller->addKeyboardInput(peerId());
     }
 }
 
diff --git a/src/input/backend/mousehandler.cpp b/src/input/backend/mousehandler.cpp
index d3f520b0d..2b086d1c9 100644
--- a/src/input/backend/mousehandler.cpp
+++ b/src/input/backend/mousehandler.cpp
@@ -85,8 +85,8 @@ void MouseHandler::setInputHandler(InputHandler *handler)
 
 void MouseHandler::mouseEvent(const QMouseEventPtr &event)
 {
-    QBackendScenePropertyChangePtr e(new QBackendScenePropertyChange(NodeUpdated, peerUuid()));
-    e->setTargetNode(peerUuid());
+    QBackendScenePropertyChangePtr e(new QBackendScenePropertyChange(NodeUpdated, peerId()));
+    e->setTargetNode(peerId());
     e->setPropertyName("mouse");
     e->setValue(QVariant::fromValue(event));
     notifyObservers(e);
@@ -94,8 +94,8 @@ void MouseHandler::mouseEvent(const QMouseEventPtr &event)
 
 void MouseHandler::wheelEvent(const QWheelEventPtr &event)
 {
-    QBackendScenePropertyChangePtr e(new QBackendScenePropertyChange(NodeUpdated, peerUuid()));
-    e->setTargetNode(peerUuid());
+    QBackendScenePropertyChangePtr e(new QBackendScenePropertyChange(NodeUpdated, peerId()));
+    e->setTargetNode(peerId());
     e->setPropertyName("wheel");
     e->setValue(QVariant::fromValue(event));
     notifyObservers(e);
@@ -119,13 +119,13 @@ void MouseHandler::setController(Qt3DCore::QNodeId controller)
     if (!m_mouseController.isNull()) {
         MouseController *controller = m_inputHandler->mouseControllerManager()->lookupResource(m_mouseController);
         if (controller)
-            controller->removeMouseInput(peerUuid());
+            controller->removeMouseInput(peerId());
     }
     m_mouseController = controller;
     if (!m_mouseController.isNull()) {
         MouseController *controller = m_inputHandler->mouseControllerManager()->lookupResource(m_mouseController);
         if (controller)
-            controller->addMouseInput(peerUuid());
+            controller->addMouseInput(peerId());
     }
 }
 
diff --git a/src/logic/manager.cpp b/src/logic/manager.cpp
index 13acd1dcc..7f0a6b4eb 100644
--- a/src/logic/manager.cpp
+++ b/src/logic/manager.cpp
@@ -74,9 +74,9 @@ void Manager::setExecutor(Executor *executor)
 
 void Manager::appendHandler(Handler *handler)
 {
-    HHandler handle = m_logicHandlerManager->lookupHandle(handler->peerUuid());
+    HHandler handle = m_logicHandlerManager->lookupHandle(handler->peerId());
     m_logicHandlers.append(handle);
-    m_logicComponentIds.append(handler->peerUuid());
+    m_logicComponentIds.append(handler->peerId());
 }
 
 void Manager::removeHandler(Qt3DCore::QNodeId id)
diff --git a/src/render/backend/boundingvolumedebug.cpp b/src/render/backend/boundingvolumedebug.cpp
index 4fa87233d..bb6cea52e 100644
--- a/src/render/backend/boundingvolumedebug.cpp
+++ b/src/render/backend/boundingvolumedebug.cpp
@@ -90,9 +90,9 @@ void BoundingVolumeDebug::setRadius(float radius)
 {
     if (m_radius != radius) {
         m_radius = radius;
-        Qt3DCore::QBackendScenePropertyChangePtr e(new Qt3DCore::QBackendScenePropertyChange(Qt3DCore::NodeUpdated, peerUuid()));
+        Qt3DCore::QBackendScenePropertyChangePtr e(new Qt3DCore::QBackendScenePropertyChange(Qt3DCore::NodeUpdated, peerId()));
         e->setPropertyName("radius");
-        e->setTargetNode(peerUuid());
+        e->setTargetNode(peerId());
         e->setValue(QVariant(radius));
         notifyObservers(e);
     }
@@ -102,9 +102,9 @@ void BoundingVolumeDebug::setCenter(const QVector3D &center)
 {
     if (m_center != center) {
         m_center = center;
-        Qt3DCore::QBackendScenePropertyChangePtr e(new Qt3DCore::QBackendScenePropertyChange(Qt3DCore::NodeUpdated, peerUuid()));
+        Qt3DCore::QBackendScenePropertyChangePtr e(new Qt3DCore::QBackendScenePropertyChange(Qt3DCore::NodeUpdated, peerId()));
         e->setPropertyName("center");
-        e->setTargetNode(peerUuid());
+        e->setTargetNode(peerId());
         e->setValue(QVariant::fromValue(center));
         notifyObservers(e);
     }
diff --git a/src/render/backend/entity.cpp b/src/render/backend/entity.cpp
index 5a25c2157..4c2650195 100644
--- a/src/render/backend/entity.cpp
+++ b/src/render/backend/entity.cpp
@@ -90,9 +90,9 @@ void Entity::cleanup()
             parentEntity->removeChildHandle(m_handle);
         for (int i = 0; i < m_childrenHandles.size(); i++)
             m_nodeManagers->renderNodesManager()->release(m_childrenHandles[i]);
-        // We need to release using peerUuid otherwise the handle will be cleared
+        // We need to release using peerId otherwise the handle will be cleared
         // but would still remain in the Id to Handle table
-        m_nodeManagers->worldMatrixManager()->releaseResource(peerUuid());
+        m_nodeManagers->worldMatrixManager()->releaseResource(peerId());
 
         qCDebug(Render::RenderNodes) << Q_FUNC_INFO;
 
@@ -148,7 +148,7 @@ void Entity::updateFromPeer(Qt3DCore::QNode *peer)
     const QNodeId parentEntityId = entityPrivate->parentEntityId();
 
     m_objectName = peer->objectName();
-    m_worldTransform = m_nodeManagers->worldMatrixManager()->getOrAcquireHandle(peerUuid());
+    m_worldTransform = m_nodeManagers->worldMatrixManager()->getOrAcquireHandle(peerId());
 
     // TO DO: Suboptimal -> Maybe have a Hash<QComponent, QEntityList> instead
     m_transformComponent = QNodeId();
@@ -160,9 +160,9 @@ void Entity::updateFromPeer(Qt3DCore::QNode *peer)
     m_layerComponents.clear();
     m_shaderDataComponents.clear();
     m_lightComponents.clear();
-    m_localBoundingVolume.reset(new Sphere(peerUuid()));
-    m_worldBoundingVolume.reset(new Sphere(peerUuid()));
-    m_worldBoundingVolumeWithChildren.reset(new Sphere(peerUuid()));
+    m_localBoundingVolume.reset(new Sphere(peerId()));
+    m_worldBoundingVolume.reset(new Sphere(peerId()));
+    m_worldBoundingVolumeWithChildren.reset(new Sphere(peerId()));
 
     Q_FOREACH (QComponent *comp, entity->components())
         addComponent(comp);
@@ -170,7 +170,7 @@ void Entity::updateFromPeer(Qt3DCore::QNode *peer)
     if (!parentEntityId.isNull()) {
         setParentHandle(m_nodeManagers->renderNodesManager()->lookupHandle(parentEntityId));
     } else {
-        qCDebug(Render::RenderNodes) << Q_FUNC_INFO << "No parent entity found for Entity" << peerUuid();
+        qCDebug(Render::RenderNodes) << Q_FUNC_INFO << "No parent entity found for Entity" << peerId();
     }
 
     m_enabled = entity->isEnabled();
diff --git a/src/render/backend/managers.cpp b/src/render/backend/managers.cpp
index 9da270e05..3e3f1e73a 100644
--- a/src/render/backend/managers.cpp
+++ b/src/render/backend/managers.cpp
@@ -53,7 +53,7 @@ bool FrameGraphManager::containsNode(Qt3DCore::QNodeId id) const
 
 void FrameGraphManager::appendNode(FrameGraphNode *node)
 {
-    m_nodes.insert(node->peerUuid(), node);
+    m_nodes.insert(node->peerId(), node);
 }
 
 FrameGraphNode* FrameGraphManager::lookupNode(Qt3DCore::QNodeId id) const
diff --git a/src/render/backend/renderview.cpp b/src/render/backend/renderview.cpp
index 4de6a8ff4..f12d89429 100644
--- a/src/render/backend/renderview.cpp
+++ b/src/render/backend/renderview.cpp
@@ -636,11 +636,11 @@ void RenderView::setUniformValue(ShaderParameterPack &uniformPack, int nameId, c
         const Qt3DCore::QNodeId texId = variant_value<Qt3DCore::QNodeId>(value);
         if ((tex = m_manager->textureManager()->lookupResource(texId))
                 != Q_NULLPTR) {
-            uniformPack.setTexture(nameId, tex->peerUuid());
+            uniformPack.setTexture(nameId, tex->peerId());
             //TextureUniform *texUniform = m_allocator->allocate<TextureUniform>();
             QUniformValue texUniform;
             texUniform.setType(QUniformValue::TextureSampler);
-            texUniform.setTextureId(tex->peerUuid());
+            texUniform.setTextureId(tex->peerId());
             uniformPack.setUniform(nameId, texUniform);
         }
     } else {
@@ -666,7 +666,7 @@ void RenderView::setUniformBlockValue(ShaderParameterPack &uniformPack,
         if ((buffer = m_manager->bufferManager()->lookupResource(variant_value<Qt3DCore::QNodeId>(value))) != Q_NULLPTR) {
             BlockToUBO uniformBlockUBO;
             uniformBlockUBO.m_blockIndex = block.m_index;
-            uniformBlockUBO.m_bufferID = buffer->peerUuid();
+            uniformBlockUBO.m_bufferID = buffer->peerId();
             uniformPack.setUniformBuffer(uniformBlockUBO);
             // Buffer update to GL buffer will be done at render time
         }
@@ -684,12 +684,12 @@ void RenderView::setUniformBlockValue(ShaderParameterPack &uniformPack,
 
         // Temporarly disabled
 
-        //        BufferShaderKey uboKey(shaderData->peerUuid(),
-        //                               shader->peerUuid());
+        //        BufferShaderKey uboKey(shaderData->peerId(),
+        //                               shader->peerId());
 
         //        BlockToUBO uniformBlockUBO;
         //        uniformBlockUBO.m_blockIndex = block.m_index;
-        //        uniformBlockUBO.m_shaderDataID = shaderData->peerUuid();
+        //        uniformBlockUBO.m_shaderDataID = shaderData->peerId();
         //        bool uboNeedsUpdate = false;
 
         //        // build UBO at uboId if not created before
@@ -734,7 +734,7 @@ void RenderView::setShaderStorageValue(ShaderParameterPack &uniformPack,
         if ((buffer = m_manager->bufferManager()->lookupResource(variant_value<Qt3DCore::QNodeId>(value))) != Q_NULLPTR) {
             BlockToSSBO shaderStorageBlock;
             shaderStorageBlock.m_blockIndex = block.m_index;
-            shaderStorageBlock.m_bufferID = buffer->peerUuid();
+            shaderStorageBlock.m_bufferID = buffer->peerId();
             uniformPack.setShaderStorageBuffer(shaderStorageBlock);
             // Buffer update to GL buffer will be done at render time
         }
diff --git a/src/render/framegraph/framegraphnode.cpp b/src/render/framegraph/framegraphnode.cpp
index 445966f29..2ba4d61fa 100644
--- a/src/render/framegraph/framegraphnode.cpp
+++ b/src/render/framegraph/framegraphnode.cpp
@@ -82,8 +82,8 @@ void FrameGraphNode::setParentId(Qt3DCore::QNodeId parentId)
     if (m_parentId != parentId) {
         m_parentId = parentId;
         FrameGraphNode *parent = m_manager->lookupNode(m_parentId);
-        if (parent != Q_NULLPTR && !parent->m_childrenIds.contains(peerUuid()))
-            parent->m_childrenIds.append(peerUuid());
+        if (parent != Q_NULLPTR && !parent->m_childrenIds.contains(peerId()))
+            parent->m_childrenIds.append(peerId());
     }
 }
 
@@ -93,7 +93,7 @@ void FrameGraphNode::appendChildId(Qt3DCore::QNodeId childId)
         FrameGraphNode *child = m_manager->lookupNode(childId);
         if (child != Q_NULLPTR) {
             m_childrenIds.append(childId);
-            child->m_parentId = peerUuid();
+            child->m_parentId = peerId();
         }
     }
 }
diff --git a/src/render/geometry/buffer.cpp b/src/render/geometry/buffer.cpp
index fe6d5f3f5..3b70161d4 100644
--- a/src/render/geometry/buffer.cpp
+++ b/src/render/geometry/buffer.cpp
@@ -87,9 +87,9 @@ void Buffer::executeFunctor()
     m_data = (*m_functor)();
     if (m_syncData) {
         // Send data back to the frontend
-        QBackendScenePropertyChangePtr e(new QBackendScenePropertyChange(NodeUpdated, peerUuid()));
+        QBackendScenePropertyChangePtr e(new QBackendScenePropertyChange(NodeUpdated, peerId()));
         e->setPropertyName("data");
-        e->setTargetNode(peerUuid());
+        e->setTargetNode(peerId());
         e->setValue(QVariant::fromValue(m_data));
         notifyObservers(e);
     }
@@ -105,7 +105,7 @@ void Buffer::updateFromPeer(Qt3DCore::QNode *peer)
         m_functor = buffer->bufferFunctor();
         // Add to dirty list in the manager
         if (m_functor && m_manager != Q_NULLPTR)
-            m_manager->addDirtyBuffer(peerUuid());
+            m_manager->addDirtyBuffer(peerId());
         m_bufferDirty = true;
         m_syncData = buffer->isSyncData();
     }
@@ -131,7 +131,7 @@ void Buffer::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
             m_bufferDirty |= !(newFunctor && m_functor && *newFunctor == *m_functor);
             m_functor = newFunctor;
             if (m_functor && m_manager != Q_NULLPTR)
-                m_manager->addDirtyBuffer(peerUuid());
+                m_manager->addDirtyBuffer(peerId());
         } else if (propertyName == QByteArrayLiteral("syncData")) {
             m_syncData = propertyChange->value().toBool();
         }
diff --git a/src/render/geometry/geometryrenderer.cpp b/src/render/geometry/geometryrenderer.cpp
index 5edc4ea79..2147a20fe 100644
--- a/src/render/geometry/geometryrenderer.cpp
+++ b/src/render/geometry/geometryrenderer.cpp
@@ -108,7 +108,7 @@ void GeometryRenderer::updateFromPeer(Qt3DCore::QNode *peer)
             m_geometryId = geometryRenderer->geometry()->id();
         m_functor = geometryRenderer->geometryFunctor();
         if (m_functor && m_manager != Q_NULLPTR)
-            m_manager->addDirtyGeometryRenderer(peerUuid());
+            m_manager->addDirtyGeometryRenderer(peerId());
         m_dirty = true;
     }
 }
@@ -149,7 +149,7 @@ void GeometryRenderer::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
             m_dirty |= !(newFunctor && m_functor && *newFunctor == *m_functor);
             m_functor = newFunctor;
             if (m_functor && m_manager != Q_NULLPTR)
-                m_manager->addDirtyGeometryRenderer(peerUuid());
+                m_manager->addDirtyGeometryRenderer(peerId());
         }
         break;
     }
@@ -184,12 +184,12 @@ void GeometryRenderer::executeFunctor()
     Q_ASSERT(m_functor);
     QGeometry *geometry = (*m_functor)();
 
-    QBackendScenePropertyChangePtr e(new QBackendScenePropertyChange(NodeUpdated, peerUuid()));
+    QBackendScenePropertyChangePtr e(new QBackendScenePropertyChange(NodeUpdated, peerId()));
     e->setPropertyName("geometry");
     // The Frontend element has to perform the clone
     // So that the objects are created in the main thread
     e->setValue(QVariant::fromValue(QNodePtr(geometry, &QNodePrivate::nodePtrDeleter)));
-    e->setTargetNode(peerUuid());
+    e->setTargetNode(peerId());
     notifyObservers(e);
     // Maybe we could also send a status to help troubleshoot errors
 }
diff --git a/src/render/graphicshelpers/graphicscontext.cpp b/src/render/graphicshelpers/graphicscontext.cpp
index f5e8c3c79..d1dce01b4 100644
--- a/src/render/graphicshelpers/graphicscontext.cpp
+++ b/src/render/graphicshelpers/graphicscontext.cpp
@@ -426,15 +426,15 @@ void GraphicsContext::activateRenderTarget(RenderTarget *renderTarget, const Att
     GLuint fboId = defaultFboId; // Default FBO
     if (renderTarget != Q_NULLPTR) {
         // New RenderTarget
-        if (!m_renderTargets.contains(renderTarget->peerUuid())) {
+        if (!m_renderTargets.contains(renderTarget->peerId())) {
             if (m_defaultFBO && fboId == m_defaultFBO) {
                 // this is the default fbo that some platforms create (iOS), we just register it
                 // Insert FBO into hash
-                m_renderTargets.insert(renderTarget->peerUuid(), fboId);
+                m_renderTargets.insert(renderTarget->peerId(), fboId);
             } else if ((fboId = m_glHelper->createFrameBufferObject()) != 0) {
                 // The FBO is created and its attachments are set once
                 // Insert FBO into hash
-                m_renderTargets.insert(renderTarget->peerUuid(), fboId);
+                m_renderTargets.insert(renderTarget->peerId(), fboId);
                 // Bind FBO
                 m_glHelper->bindFrameBufferObject(fboId);
                 bindFrameBufferAttachmentHelper(fboId, attachments);
@@ -442,7 +442,7 @@ void GraphicsContext::activateRenderTarget(RenderTarget *renderTarget, const Att
                 qCritical() << "Failed to create FBO";
             }
         } else {
-            fboId = m_renderTargets.value(renderTarget->peerUuid());
+            fboId = m_renderTargets.value(renderTarget->peerId());
 
             // We need to check if  one of the attachment was resized
             TextureManager *textureManager = m_renderer->nodeManagers()->textureManager();
@@ -1075,21 +1075,21 @@ void GraphicsContext::specifyIndices(Buffer *buffer)
 
 void GraphicsContext::updateBuffer(Buffer *buffer)
 {
-    const QHash<Qt3DCore::QNodeId, HGLBuffer>::iterator it = m_renderBufferHash.find(buffer->peerUuid());
+    const QHash<Qt3DCore::QNodeId, HGLBuffer>::iterator it = m_renderBufferHash.find(buffer->peerId());
     if (it != m_renderBufferHash.end())
         uploadDataToGLBuffer(buffer, m_renderer->nodeManagers()->glBufferManager()->data(it.value()));
 }
 
 GLBuffer *GraphicsContext::glBufferForRenderBuffer(Buffer *buf)
 {
-    if (!m_renderBufferHash.contains(buf->peerUuid()))
-        m_renderBufferHash.insert(buf->peerUuid(), createGLBufferFor(buf));
-    return m_renderer->nodeManagers()->glBufferManager()->data(m_renderBufferHash.value(buf->peerUuid()));
+    if (!m_renderBufferHash.contains(buf->peerId()))
+        m_renderBufferHash.insert(buf->peerId(), createGLBufferFor(buf));
+    return m_renderer->nodeManagers()->glBufferManager()->data(m_renderBufferHash.value(buf->peerId()));
 }
 
 HGLBuffer GraphicsContext::createGLBufferFor(Buffer *buffer)
 {
-    GLBuffer *b = m_renderer->nodeManagers()->glBufferManager()->getOrCreateResource(buffer->peerUuid());
+    GLBuffer *b = m_renderer->nodeManagers()->glBufferManager()->getOrCreateResource(buffer->peerId());
     //    b.setUsagePattern(static_cast<QOpenGLBuffer::UsagePattern>(buffer->usage()));
     Q_ASSERT(b);
     if (!b->create(this))
@@ -1100,7 +1100,7 @@ HGLBuffer GraphicsContext::createGLBufferFor(Buffer *buffer)
 
     // TO DO: Handle usage pattern
     b->allocate(this, buffer->data().constData(), buffer->data().size(), false);
-    return m_renderer->nodeManagers()->glBufferManager()->lookupHandle(buffer->peerUuid());
+    return m_renderer->nodeManagers()->glBufferManager()->lookupHandle(buffer->peerId());
 }
 
 void GraphicsContext::uploadDataToGLBuffer(Buffer *buffer, GLBuffer *b, bool releaseBuffer)
diff --git a/src/render/io/scene.cpp b/src/render/io/scene.cpp
index 333698500..e08db21e5 100644
--- a/src/render/io/scene.cpp
+++ b/src/render/io/scene.cpp
@@ -64,7 +64,7 @@ void Scene::updateFromPeer(Qt3DCore::QNode *peer)
     QAbstractSceneLoader *loader = static_cast<QAbstractSceneLoader *>(peer);
 
     m_source = loader->source();
-    m_sceneManager->addSceneData(m_source, peerUuid());
+    m_sceneManager->addSceneData(m_source, peerId());
 }
 
 void Scene::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
@@ -72,7 +72,7 @@ void Scene::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
     QScenePropertyChangePtr propertyChange = qSharedPointerCast<QScenePropertyChange>(e);
     if (propertyChange->propertyName() == QByteArrayLiteral("source")) {
         m_source = propertyChange->value().toUrl();
-        m_sceneManager->addSceneData(m_source, peerUuid());
+        m_sceneManager->addSceneData(m_source, peerId());
     }
     markDirty(AbstractRenderer::AllDirty);
 }
@@ -84,17 +84,17 @@ QUrl Scene::source() const
 
 void Scene::setSceneSubtree(Qt3DCore::QEntity *subTree)
 {
-    QBackendScenePropertyChangePtr e(new QBackendScenePropertyChange(NodeUpdated, peerUuid()));
+    QBackendScenePropertyChangePtr e(new QBackendScenePropertyChange(NodeUpdated, peerId()));
     e->setPropertyName("scene");
     // The Frontend element has to perform the clone
     // So that the objects are created in the main thread
     e->setValue(QVariant::fromValue(QNodePtr(subTree, &QNodePrivate::nodePtrDeleter)));
-    e->setTargetNode(peerUuid());
+    e->setTargetNode(peerId());
     notifyObservers(e);
-    QBackendScenePropertyChangePtr e2(new QBackendScenePropertyChange(NodeUpdated, peerUuid()));
+    QBackendScenePropertyChangePtr e2(new QBackendScenePropertyChange(NodeUpdated, peerId()));
     e2->setPropertyName("status");
     e2->setValue(subTree != Q_NULLPTR ? QAbstractSceneLoader::Loaded : QAbstractSceneLoader::Error);
-    e2->setTargetNode(peerUuid());
+    e2->setTargetNode(peerId());
     notifyObservers(e2);
 }
 
diff --git a/src/render/jobs/pickboundingvolumejob.cpp b/src/render/jobs/pickboundingvolumejob.cpp
index 894a4349a..59dee252e 100644
--- a/src/render/jobs/pickboundingvolumejob.cpp
+++ b/src/render/jobs/pickboundingvolumejob.cpp
@@ -182,7 +182,7 @@ private:
                uint bndx, const QVector3D &b,
                uint cndx, const QVector3D &c)
     {
-        TriangleBoundingVolume volume(m_root->peerUuid(), a, b, c);
+        TriangleBoundingVolume volume(m_root->peerId(), a, b, c);
         volume = volume.transform(*m_root->worldTransform());
 
         QCollisionQueryResult::Hit queryResult = rayCasting.query(m_ray, &volume);
@@ -232,7 +232,7 @@ struct CollisionGathererFunctor
 
         if (rayHitsEntity(&rayCasting, entity)) {
             CollisionVisitor visitor(m_renderer->nodeManagers(), entity, m_ray);
-            visitor.apply(gRenderer, entity->peerUuid());
+            visitor.apply(gRenderer, entity->peerId());
             result = visitor.hits;
 
             struct
diff --git a/src/render/materialsystem/shaderdata.cpp b/src/render/materialsystem/shaderdata.cpp
index 1af45b81d..3330eaa77 100644
--- a/src/render/materialsystem/shaderdata.cpp
+++ b/src/render/materialsystem/shaderdata.cpp
@@ -233,8 +233,8 @@ bool ShaderData::updateWorldTransform(const QMatrix4x4 &worldMatrix)
 void ShaderData::markDirty()
 {
     QMutexLocker lock(&m_mutex);
-    if (!ShaderData::m_updatedShaderData.contains(peerUuid()))
-        ShaderData::m_updatedShaderData.append(peerUuid());
+    if (!ShaderData::m_updatedShaderData.contains(peerId()))
+        ShaderData::m_updatedShaderData.append(peerId());
 }
 
 void ShaderData::readPeerProperties(QShaderData *shaderData)
diff --git a/src/render/picking/objectpicker.cpp b/src/render/picking/objectpicker.cpp
index ae5833312..12f2dd614 100644
--- a/src/render/picking/objectpicker.cpp
+++ b/src/render/picking/objectpicker.cpp
@@ -131,27 +131,27 @@ bool ObjectPicker::isDragEnabled() const
 
 void ObjectPicker::onClicked(QPickEventPtr event)
 {
-    Qt3DCore::QBackendScenePropertyChangePtr e(new Qt3DCore::QBackendScenePropertyChange(Qt3DCore::NodeUpdated, peerUuid()));
+    Qt3DCore::QBackendScenePropertyChangePtr e(new Qt3DCore::QBackendScenePropertyChange(Qt3DCore::NodeUpdated, peerId()));
     e->setPropertyName("clicked");
-    e->setTargetNode(peerUuid());
+    e->setTargetNode(peerId());
     e->setValue(QVariant::fromValue(event));
     notifyObservers(e);
 }
 
 void ObjectPicker::onMoved(QPickEventPtr event)
 {
-    Qt3DCore::QBackendScenePropertyChangePtr e(new Qt3DCore::QBackendScenePropertyChange(Qt3DCore::NodeUpdated, peerUuid()));
+    Qt3DCore::QBackendScenePropertyChangePtr e(new Qt3DCore::QBackendScenePropertyChange(Qt3DCore::NodeUpdated, peerId()));
     e->setPropertyName("moved");
-    e->setTargetNode(peerUuid());
+    e->setTargetNode(peerId());
     e->setValue(QVariant::fromValue(event));
     notifyObservers(e);
 }
 
 void ObjectPicker::onPressed(QPickEventPtr event)
 {
-    Qt3DCore::QBackendScenePropertyChangePtr e(new Qt3DCore::QBackendScenePropertyChange(Qt3DCore::NodeUpdated, peerUuid()));
+    Qt3DCore::QBackendScenePropertyChangePtr e(new Qt3DCore::QBackendScenePropertyChange(Qt3DCore::NodeUpdated, peerId()));
     e->setPropertyName("pressed");
-    e->setTargetNode(peerUuid());
+    e->setTargetNode(peerId());
     e->setValue(QVariant::fromValue(event));
     m_isPressed = true;
     notifyObservers(e);
@@ -159,9 +159,9 @@ void ObjectPicker::onPressed(QPickEventPtr event)
 
 void ObjectPicker::onReleased(QPickEventPtr event)
 {
-    Qt3DCore::QBackendScenePropertyChangePtr e(new Qt3DCore::QBackendScenePropertyChange(Qt3DCore::NodeUpdated, peerUuid()));
+    Qt3DCore::QBackendScenePropertyChangePtr e(new Qt3DCore::QBackendScenePropertyChange(Qt3DCore::NodeUpdated, peerId()));
     e->setPropertyName("released");
-    e->setTargetNode(peerUuid());
+    e->setTargetNode(peerId());
     e->setValue(QVariant::fromValue(event));
     m_isPressed = false;
     notifyObservers(e);
@@ -169,17 +169,17 @@ void ObjectPicker::onReleased(QPickEventPtr event)
 
 void ObjectPicker::onEntered()
 {
-    Qt3DCore::QBackendScenePropertyChangePtr e(new Qt3DCore::QBackendScenePropertyChange(Qt3DCore::NodeUpdated, peerUuid()));
+    Qt3DCore::QBackendScenePropertyChangePtr e(new Qt3DCore::QBackendScenePropertyChange(Qt3DCore::NodeUpdated, peerId()));
     e->setPropertyName("entered");
-    e->setTargetNode(peerUuid());
+    e->setTargetNode(peerId());
     notifyObservers(e);
 }
 
 void ObjectPicker::onExited()
 {
-    Qt3DCore::QBackendScenePropertyChangePtr e(new Qt3DCore::QBackendScenePropertyChange(Qt3DCore::NodeUpdated, peerUuid()));
+    Qt3DCore::QBackendScenePropertyChangePtr e(new Qt3DCore::QBackendScenePropertyChange(Qt3DCore::NodeUpdated, peerId()));
     e->setPropertyName("exited");
-    e->setTargetNode(peerUuid());
+    e->setTargetNode(peerId());
     notifyObservers(e);
 }
 
diff --git a/src/render/texture/texture.cpp b/src/render/texture/texture.cpp
index 5bec73f39..64841a87a 100644
--- a/src/render/texture/texture.cpp
+++ b/src/render/texture/texture.cpp
@@ -443,7 +443,7 @@ void Texture::updateDNA()
             m_textureDNA += img->dna();
     }
     if (m_unique) // Ensures uniqueness by adding unique QNode id to the dna
-        m_textureDNA += qHash(peerUuid());
+        m_textureDNA += qHash(peerId());
 }
 
 // RenderThread
@@ -671,7 +671,7 @@ void Texture::requestTextureDataUpdate()
 // Called by RenderTextureImages
 void Texture::addToPendingTextureJobs()
 {
-    m_textureDataManager->addToPendingTextures(peerUuid());
+    m_textureDataManager->addToPendingTextures(peerId());
 }
 
 TextureFunctor::TextureFunctor(AbstractRenderer *renderer,
diff --git a/src/render/texture/textureimage.cpp b/src/render/texture/textureimage.cpp
index ebcfc7dbf..a6ed8cb0a 100644
--- a/src/render/texture/textureimage.cpp
+++ b/src/render/texture/textureimage.cpp
@@ -91,7 +91,7 @@ void TextureImage::updateFromPeer(Qt3DCore::QNode *peer)
         m_textureProvider = m_textureManager->lookupHandle(m_textureProviderId);
         Texture *txt = m_textureManager->data(m_textureProvider);
         // Notify the Texture that it has a new TextureImage and needs an update
-        txt->addTextureImageData(m_textureImageManager->lookupHandle(peerUuid()));
+        txt->addTextureImageData(m_textureImageManager->lookupHandle(peerId()));
         if (txt != Q_NULLPTR)
             txt->addToPendingTextureJobs();
     }