Rename QNodeUuid to QNodeId

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

75 files changed, 339 insertions, 339 deletions

diff --git a/src/core/nodes/nodes.pri b/src/core/nodes/nodes.pri
index a940f3665..5edfb4d82 100644
--- a/src/core/nodes/nodes.pri
+++ b/src/core/nodes/nodes.pri
@@ -9,7 +9,7 @@ HEADERS += \
     $$PWD/qentity_p.h \
     $$PWD/qbackendnode_p.h \
     $$PWD/qbackendnode.h \
-    $$PWD/qnodeuuid.h \
+    $$PWD/qnodeid.h \
     $$PWD/qnodevisitor.h
 
 SOURCES += \
@@ -17,6 +17,6 @@ SOURCES += \
     $$PWD/qcomponent.cpp \
     $$PWD/qentity.cpp \
     $$PWD/qbackendnode.cpp \
-    $$PWD/qnodeuuid.cpp \
+    $$PWD/qnodeid.cpp \
     $$PWD/qnodevisitor.cpp
 
diff --git a/src/core/nodes/qbackendnode.cpp b/src/core/nodes/qbackendnode.cpp
index 80ff9aa36..5ca8b1a3d 100644
--- a/src/core/nodes/qbackendnode.cpp
+++ b/src/core/nodes/qbackendnode.cpp
@@ -95,14 +95,14 @@ QBackendNode::~QBackendNode()
 void QBackendNode::setPeer(QNode *peer)
 {
     Q_D(QBackendNode);
-    QNodeUuid peerUuid;
+    QNodeId peerUuid;
     if (peer != Q_NULLPTR)
         peerUuid = peer->uuid();
     d->m_peerUuid = peerUuid;
     updateFromPeer(peer);
 }
 
-QNodeUuid QBackendNode::peerUuid() const
+QNodeId QBackendNode::peerUuid() const
 {
     Q_D(const QBackendNode);
     return d->m_peerUuid;
diff --git a/src/core/nodes/qbackendnode.h b/src/core/nodes/qbackendnode.h
index 237498067..f237b3773 100644
--- a/src/core/nodes/qbackendnode.h
+++ b/src/core/nodes/qbackendnode.h
@@ -44,7 +44,7 @@
 
 #include <Qt3DCore/qt3dcore_global.h>
 #include <Qt3DCore/qscenechange.h>
-#include <Qt3DCore/qnodeuuid.h>
+#include <Qt3DCore/qnodeid.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -77,7 +77,7 @@ public:
     virtual ~QBackendNode();
 
     void setPeer(QNode *peer);
-    QNodeUuid peerUuid() const;
+    QNodeId peerUuid() const;
 
     Mode mode() const;
     virtual void updateFromPeer(QNode *peer) = 0;
diff --git a/src/core/nodes/qbackendnode_p.h b/src/core/nodes/qbackendnode_p.h
index 0c930f14c..5c8a4f92b 100644
--- a/src/core/nodes/qbackendnode_p.h
+++ b/src/core/nodes/qbackendnode_p.h
@@ -42,7 +42,7 @@
 #ifndef QT3D_QBACKENDNODE_P_H
 #define QT3D_QBACKENDNODE_P_H
 
-#include <Qt3DCore/qnodeuuid.h>
+#include <Qt3DCore/qnodeid.h>
 #include <Qt3DCore/private/qobservableinterface_p.h>
 #include <Qt3DCore/private/qobserverinterface_p.h>
 #include <Qt3DCore/qbackendnode.h>
@@ -70,7 +70,7 @@ public:
     QBackendNode::Mode m_mode;
 
     QChangeArbiter *m_arbiter;
-    QNodeUuid m_peerUuid;
+    QNodeId m_peerUuid;
 };
 
 } // Qt3D
diff --git a/src/core/nodes/qnode.cpp b/src/core/nodes/qnode.cpp
index 72708b474..959cf3ab6 100644
--- a/src/core/nodes/qnode.cpp
+++ b/src/core/nodes/qnode.cpp
@@ -57,13 +57,13 @@ QT_BEGIN_NAMESPACE
 
 namespace Qt3D {
 
-QHash<QNodeUuid, QNode *> QNodePrivate::m_clonesLookupTable = QHash<QNodeUuid, QNode *>();
+QHash<QNodeId, QNode *> QNodePrivate::m_clonesLookupTable = QHash<QNodeId, QNode *>();
 
 QNodePrivate::QNodePrivate(QNode *qq)
     : QObjectPrivate()
     , m_changeArbiter(Q_NULLPTR)
     , m_scene(Q_NULLPTR)
-    , m_uuid(QNodeUuid::createUuid())
+    , m_uuid(QNodeId::createUuid())
     , m_blockNotifications(false)
     , m_propertyChangesSetup(false)
     , m_signals(this)
@@ -224,7 +224,7 @@ void QNodePrivate::propertyChanged(int propertyIndex)
     const QVariant data = property.read(q);
     if (data.canConvert<QNode*>()) {
         const QNode * const node = data.value<QNode*>();
-        const QNodeUuid uuid = node ? node->uuid() : QNodeUuid();
+        const QNodeId uuid = node ? node->uuid() : QNodeId();
         notifyPropertyChange(property.name(), QVariant::fromValue(uuid));
     } else {
         notifyPropertyChange(property.name(), data);
@@ -343,7 +343,7 @@ QNode::~QNode()
 {
 }
 
-const QNodeUuid QNode::uuid() const
+const QNodeId QNode::uuid() const
 {
     Q_D(const QNode);
     return d->m_uuid;
diff --git a/src/core/nodes/qnode.h b/src/core/nodes/qnode.h
index 9056aae0c..01da4d961 100644
--- a/src/core/nodes/qnode.h
+++ b/src/core/nodes/qnode.h
@@ -44,7 +44,7 @@
 
 #include <QObject>
 #include <Qt3DCore/qt3dcore_global.h>
-#include <Qt3DCore/qnodeuuid.h>
+#include <Qt3DCore/qnodeid.h>
 #include <Qt3DCore/qscenechange.h>
 
 QT_BEGIN_NAMESPACE
@@ -74,7 +74,7 @@ public:
     explicit QNode(QNode *parent = 0);
     ~QNode();
 
-    const QNodeUuid uuid() const;
+    const QNodeId uuid() const;
     QNode *parentNode() const;
 
     bool notificationsBlocked() const;
diff --git a/src/core/nodes/qnode_p.h b/src/core/nodes/qnode_p.h
index 5aa584c2b..4271f7d13 100644
--- a/src/core/nodes/qnode_p.h
+++ b/src/core/nodes/qnode_p.h
@@ -80,7 +80,7 @@ public:
     // Later on we may decide to extend support for multiple observers.
     QChangeArbiter *m_changeArbiter;
     QSceneInterface *m_scene;
-    mutable QNodeUuid m_uuid;
+    mutable QNodeId m_uuid;
     bool m_blockNotifications;
 
     static QNodePrivate *get(QNode *q);
@@ -98,7 +98,7 @@ private:
     bool m_propertyChangesSetup;
     PropertyChangeHandler<QNodePrivate> m_signals;
 
-    static QHash<QNodeUuid, QNode *> m_clonesLookupTable;
+    static QHash<QNodeId, QNode *> m_clonesLookupTable;
 };
 
 } // namespace Qt3D
diff --git a/src/core/nodes/qnodeuuid.cpp b/src/core/nodes/qnodeid.cpp
index 00c95db33..f6aeb3157 100644
--- a/src/core/nodes/qnodeuuid.cpp
+++ b/src/core/nodes/qnodeid.cpp
@@ -39,25 +39,25 @@
 **
 ****************************************************************************/
 
-#include "qnodeuuid.h"
+#include "qnodeid.h"
 
 QT_BEGIN_NAMESPACE
 
 namespace Qt3D {
 
-QNodeUuid QNodeUuid::createUuid()
+QNodeId QNodeId::createUuid()
 {
 #if defined(Q_ATOMIC_INT64_IS_SUPPORTED)
     static QAtomicInteger<quint64> m_curId = QAtomicInteger<quint64>(1);
 #else
     static QAtomicInteger<quint32> m_curId = QAtomicInteger<quint32>(1);
 #endif
-    QNodeUuid uuid;
+    QNodeId uuid;
     uuid.m_uuid = m_curId.fetchAndAddOrdered(1);
     return uuid;
 }
 
-QDebug operator<<(QDebug d, const QNodeUuid &id)
+QDebug operator<<(QDebug d, const QNodeId &id)
 {
     d << id.guid();
     return d;
diff --git a/src/core/nodes/qnodeuuid.h b/src/core/nodes/qnodeid.h
index ebd6f61b1..6e2fcf284 100644
--- a/src/core/nodes/qnodeuuid.h
+++ b/src/core/nodes/qnodeid.h
@@ -39,8 +39,8 @@
 **
 ****************************************************************************/
 
-#ifndef QT3D_QNODEUUID_H
-#define QT3D_QNODEUUID_H
+#ifndef QT3D_QNODEID_H
+#define QT3D_QNODEID_H
 
 #include <Qt3DCore/qt3dcore_global.h>
 #include <QDebug>
@@ -49,36 +49,36 @@ QT_BEGIN_NAMESPACE
 
 namespace Qt3D {
 
-class QT3DCORESHARED_EXPORT QNodeUuid
+class QT3DCORESHARED_EXPORT QNodeId
 {
 public:
-    QNodeUuid()
+    QNodeId()
         : m_uuid(0)
     {}
 
-    static QNodeUuid createUuid();
+    static QNodeId createUuid();
 
     inline bool isNull() const
     {
         return m_uuid == 0;
     }
 
-    inline bool operator ==(const QNodeUuid &other) const
+    inline bool operator ==(const QNodeId &other) const
     {
         return other.m_uuid == m_uuid;
     }
 
-    inline bool operator !=(const QNodeUuid &other) const
+    inline bool operator !=(const QNodeId &other) const
     {
         return !operator ==(other);
     }
 
-    inline bool operator <(const QNodeUuid &other) const
+    inline bool operator <(const QNodeId &other) const
     {
         return m_uuid < other.m_uuid;
     }
 
-    inline bool operator >(const QNodeUuid &other) const
+    inline bool operator >(const QNodeId &other) const
     {
         return m_uuid > other.m_uuid;
     }
@@ -94,21 +94,21 @@ private:
 
 
 #ifndef QT_NO_DEBUG_STREAM
-QT3DCORESHARED_EXPORT QDebug operator<<(QDebug d, const QNodeUuid &id);
+QT3DCORESHARED_EXPORT QDebug operator<<(QDebug d, const QNodeId &id);
 #endif
 
-QT3DCORESHARED_EXPORT inline uint qHash(const QNodeUuid &uuid, uint) Q_DECL_NOTHROW
+QT3DCORESHARED_EXPORT inline uint qHash(const QNodeId &uuid, uint) Q_DECL_NOTHROW
 {
     return uuid.guid();
 }
 
 } // Qt3D
 
-Q_DECLARE_TYPEINFO(Qt3D::QNodeUuid, Q_MOVABLE_TYPE);
+Q_DECLARE_TYPEINFO(Qt3D::QNodeId, Q_MOVABLE_TYPE);
 
 QT_END_NAMESPACE
 
-Q_DECLARE_METATYPE(Qt3D::QNodeUuid)
+Q_DECLARE_METATYPE(Qt3D::QNodeId)
 
 
-#endif // QT3D_QNODEUUID_H
+#endif // QT3D_QNODEID_H
diff --git a/src/core/qbackendscenepropertychange.cpp b/src/core/qbackendscenepropertychange.cpp
index a82892554..e4d301db8 100644
--- a/src/core/qbackendscenepropertychange.cpp
+++ b/src/core/qbackendscenepropertychange.cpp
@@ -66,13 +66,13 @@ QBackendScenePropertyChange::~QBackendScenePropertyChange()
 {
 }
 
-void QBackendScenePropertyChange::setTargetNode(const QNodeUuid &id)
+void QBackendScenePropertyChange::setTargetNode(const QNodeId &id)
 {
     Q_D(QBackendScenePropertyChange);
     d->m_targetUuid = id;
 }
 
-QNodeUuid QBackendScenePropertyChange::targetNode() const
+QNodeId QBackendScenePropertyChange::targetNode() const
 {
     Q_D(const QBackendScenePropertyChange);
     return d->m_targetUuid;
diff --git a/src/core/qbackendscenepropertychange.h b/src/core/qbackendscenepropertychange.h
index f7a6c34c3..539a829c6 100644
--- a/src/core/qbackendscenepropertychange.h
+++ b/src/core/qbackendscenepropertychange.h
@@ -43,7 +43,7 @@
 #define QT3D_QBACKENDSCENEPROPERTYCHANGE_H
 
 #include <Qt3DCore/qscenepropertychange.h>
-#include <Qt3DCore/qnodeuuid.h>
+#include <Qt3DCore/qnodeid.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -59,8 +59,8 @@ public:
                                 Priority priority = Standard);
     virtual ~QBackendScenePropertyChange();
 
-    void setTargetNode(const QNodeUuid &id);
-    QNodeUuid targetNode() const;
+    void setTargetNode(const QNodeId &id);
+    QNodeId targetNode() const;
 
 protected:
     Q_DECLARE_PRIVATE(QBackendScenePropertyChange)
diff --git a/src/core/qbackendscenepropertychange_p.h b/src/core/qbackendscenepropertychange_p.h
index 842650517..4be5952a6 100644
--- a/src/core/qbackendscenepropertychange_p.h
+++ b/src/core/qbackendscenepropertychange_p.h
@@ -43,7 +43,7 @@
 #define QT3D_QBACKENDSCENEPROPERTYCHANGE_P_H
 
 #include <private/qscenepropertychange_p.h>
-#include <Qt3DCore/qnodeuuid.h>
+#include <Qt3DCore/qnodeid.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -59,7 +59,7 @@ public:
 
     Q_DECLARE_PUBLIC(QBackendScenePropertyChange)
 
-    QNodeUuid m_targetUuid;
+    QNodeId m_targetUuid;
 };
 
 } // Qt3D
diff --git a/src/core/qchangearbiter.cpp b/src/core/qchangearbiter.cpp
index e8f0a1f04..355aa1a1f 100644
--- a/src/core/qchangearbiter.cpp
+++ b/src/core/qchangearbiter.cpp
@@ -131,7 +131,7 @@ void QChangeArbiter::distributeQueueChanges(ChangeQueue *changeQueue)
 
         case QSceneChange::Observable: {
             QObservableInterface *subject = change->subject().m_observable;
-            QNodeUuid nodeId = m_scene->nodeIdFromObservable(subject);
+            QNodeId nodeId = m_scene->nodeIdFromObservable(subject);
             if (m_nodeObservations.contains(nodeId)) {
                 QObserverList &observers = m_nodeObservations[nodeId];
                 Q_FOREACH (const QObserverPair&observer, observers) {
@@ -216,7 +216,7 @@ QSceneInterface *QChangeArbiter::scene() const
 }
 
 void QChangeArbiter::registerObserver(QObserverInterface *observer,
-                                      const QNodeUuid &nodeId,
+                                      const QNodeId &nodeId,
                                       ChangeFlags changeFlags)
 {
     QMutexLocker locker(&m_mutex);
@@ -231,7 +231,7 @@ void QChangeArbiter::registerSceneObserver(QSceneObserverInterface *observer)
         m_sceneObservers << observer;
 }
 
-void QChangeArbiter::unregisterObserver(QObserverInterface *observer, const QNodeUuid &nodeId)
+void QChangeArbiter::unregisterObserver(QObserverInterface *observer, const QNodeId &nodeId)
 {
     QMutexLocker locker(&m_mutex);
     if (m_nodeObservations.contains(nodeId)) {
diff --git a/src/core/qchangearbiter_p.h b/src/core/qchangearbiter_p.h
index db44acaa2..75509ed49 100644
--- a/src/core/qchangearbiter_p.h
+++ b/src/core/qchangearbiter_p.h
@@ -50,7 +50,7 @@
 #include <QPair>
 #include <QThreadStorage>
 #include <QMutex>
-#include <Qt3DCore/qnodeuuid.h>
+#include <Qt3DCore/qnodeid.h>
 #include <Qt3DCore/qscenechange.h>
 #include <Qt3DCore/private/qobserverinterface_p.h>
 
@@ -83,10 +83,10 @@ public:
     void syncChanges();
 
     void registerObserver(QObserverInterface *observer,
-                          const QNodeUuid &nodeId,
+                          const QNodeId &nodeId,
                           ChangeFlags changeFlags = AllChanges);
     void unregisterObserver(QObserverInterface *observer,
-                            const QNodeUuid &nodeId);
+                            const QNodeId &nodeId);
 
     void registerSceneObserver(QSceneObserverInterface *observer);
     void unregisterSceneObserver(QSceneObserverInterface *observer);
@@ -130,7 +130,7 @@ private:
     //
     // We keep these distinct because we do not manage the main thread which means
     // the mechanisms for working with objects there is different.
-    QHash<QNodeUuid, QObserverList> m_nodeObservations;
+    QHash<QNodeId, QObserverList> m_nodeObservations;
     QList<QSceneObserverInterface *> m_sceneObservers;
 
     // Each thread has a TLS ChangeQueue so we never need to lock whilst
diff --git a/src/core/qscene.cpp b/src/core/qscene.cpp
index 1b6b69279..0b6ea6d7c 100644
--- a/src/core/qscene.cpp
+++ b/src/core/qscene.cpp
@@ -62,12 +62,12 @@ public:
 
     Q_DECLARE_PUBLIC(QScene)
     QScene *q_ptr;
-    QHash<QNodeUuid, QNode *> m_nodeLookupTable;
-    QMultiHash<QNodeUuid, QNodeUuid> m_componentToEntities;
-    QMultiHash<QNodeUuid, QObservableInterface *> m_observablesLookupTable;
-    QHash<QObservableInterface *, QNodeUuid> m_observableToUuid;
+    QHash<QNodeId, QNode *> m_nodeLookupTable;
+    QMultiHash<QNodeId, QNodeId> m_componentToEntities;
+    QMultiHash<QNodeId, QObservableInterface *> m_observablesLookupTable;
+    QHash<QObservableInterface *, QNodeId> m_observableToUuid;
     QChangeArbiter *m_arbiter;
-    QHash<QNodeUuid, QNode *> m_clonesLookupTable;
+    QHash<QNodeId, QNode *> m_clonesLookupTable;
     mutable QReadWriteLock m_lock;
 };
 
@@ -78,7 +78,7 @@ QScene::QScene()
 }
 
 // Called by any thread
-void QScene::addObservable(QObservableInterface *observable, const QNodeUuid &uuid)
+void QScene::addObservable(QObservableInterface *observable, const QNodeId &uuid)
 {
     Q_D(QScene);
     QWriteLocker lock(&d->m_lock);
@@ -101,7 +101,7 @@ void QScene::addObservable(QNode *observable)
 }
 
 // Called by any thread
-void QScene::removeObservable(QObservableInterface *observable, const QNodeUuid &uuid)
+void QScene::removeObservable(QObservableInterface *observable, const QNodeId &uuid)
 {
     Q_D(QScene);
     QWriteLocker lock(&d->m_lock);
@@ -116,7 +116,7 @@ void QScene::removeObservable(QNode *observable)
     Q_D(QScene);
     if (observable != Q_NULLPTR) {
         QWriteLocker lock(&d->m_lock);
-        QNodeUuid nodeUuid = observable->uuid();
+        QNodeId nodeUuid = observable->uuid();
         QObservableList observables = d->m_observablesLookupTable.values(nodeUuid);
         Q_FOREACH (QObservableInterface *o, observables) {
             o->setArbiter(Q_NULLPTR);
@@ -129,7 +129,7 @@ void QScene::removeObservable(QNode *observable)
 }
 
 // Called by any thread
-QObservableList QScene::lookupObservables(const QNodeUuid &uuid) const
+QObservableList QScene::lookupObservables(const QNodeId &uuid) const
 {
     Q_D(const QScene);
     QReadLocker lock(&d->m_lock);
@@ -137,14 +137,14 @@ QObservableList QScene::lookupObservables(const QNodeUuid &uuid) const
 }
 
 // Called by any thread
-QNode *QScene::lookupNode(const QNodeUuid &uuid) const
+QNode *QScene::lookupNode(const QNodeId &uuid) const
 {
     Q_D(const QScene);
     QReadLocker lock(&d->m_lock);
     return d->m_nodeLookupTable.value(uuid);
 }
 
-QNodeUuid QScene::nodeIdFromObservable(QObservableInterface *observable) const
+QNodeId QScene::nodeIdFromObservable(QObservableInterface *observable) const
 {
     Q_D(const QScene);
     QReadLocker lock(&d->m_lock);
@@ -157,21 +157,21 @@ void QScene::setArbiter(QChangeArbiter *arbiter)
     d->m_arbiter = arbiter;
 }
 
-QList<QNodeUuid> QScene::entitiesForComponent(const QNodeUuid &uuid) const
+QList<QNodeId> QScene::entitiesForComponent(const QNodeId &uuid) const
 {
     Q_D(const QScene);
     QReadLocker lock(&d->m_lock);
     return d->m_componentToEntities.values(uuid);
 }
 
-void QScene::addEntityForComponent(const QNodeUuid &componentUuid, const QNodeUuid &entityUuid)
+void QScene::addEntityForComponent(const QNodeId &componentUuid, const QNodeId &entityUuid)
 {
     Q_D(QScene);
     QWriteLocker lock(&d->m_lock);
     d->m_componentToEntities.insert(componentUuid, entityUuid);
 }
 
-void QScene::removeEntityForComponent(const QNodeUuid &componentUuid, const QNodeUuid &entityUuid)
+void QScene::removeEntityForComponent(const QNodeId &componentUuid, const QNodeId &entityUuid)
 {
     Q_D(QScene);
     QWriteLocker lock(&d->m_lock);
diff --git a/src/core/qscene.h b/src/core/qscene.h
index a35d639ac..e5f750244 100644
--- a/src/core/qscene.h
+++ b/src/core/qscene.h
@@ -57,21 +57,21 @@ class QT3DCORESHARED_EXPORT QScene : public QSceneInterface
 public:
     QScene();
 
-    void addObservable(QObservableInterface *observable, const QNodeUuid &uuid) Q_DECL_OVERRIDE;
+    void addObservable(QObservableInterface *observable, const QNodeId &uuid) Q_DECL_OVERRIDE;
     void addObservable(QNode *observable) Q_DECL_OVERRIDE;
-    void removeObservable(QObservableInterface *observable, const QNodeUuid &uuid) Q_DECL_OVERRIDE;
+    void removeObservable(QObservableInterface *observable, const QNodeId &uuid) Q_DECL_OVERRIDE;
     void removeObservable(QNode *observable) Q_DECL_OVERRIDE;
-    QObservableList lookupObservables(const QNodeUuid &uuid) const Q_DECL_OVERRIDE;
+    QObservableList lookupObservables(const QNodeId &uuid) const Q_DECL_OVERRIDE;
 
-    QNode *lookupNode(const QNodeUuid &uuid) const Q_DECL_OVERRIDE;
-    QNodeUuid nodeIdFromObservable(QObservableInterface *observable) const Q_DECL_OVERRIDE;
+    QNode *lookupNode(const QNodeId &uuid) const Q_DECL_OVERRIDE;
+    QNodeId nodeIdFromObservable(QObservableInterface *observable) const Q_DECL_OVERRIDE;
 
     void setArbiter(QChangeArbiter *arbiter) Q_DECL_OVERRIDE;
 
     // Component -> Entities
-    QList<QNodeUuid> entitiesForComponent(const QNodeUuid &uuid) const Q_DECL_OVERRIDE;
-    void addEntityForComponent(const QNodeUuid &componentUuid, const QNodeUuid &entityUuid) Q_DECL_OVERRIDE;
-    void removeEntityForComponent(const QNodeUuid &componentUuid, const QNodeUuid &entityUuid) Q_DECL_OVERRIDE;
+    QList<QNodeId> entitiesForComponent(const QNodeId &uuid) const Q_DECL_OVERRIDE;
+    void addEntityForComponent(const QNodeId &componentUuid, const QNodeId &entityUuid) Q_DECL_OVERRIDE;
+    void removeEntityForComponent(const QNodeId &componentUuid, const QNodeId &entityUuid) Q_DECL_OVERRIDE;
 
 private:
     Q_DECLARE_PRIVATE(QScene)
diff --git a/src/core/qsceneinterface.h b/src/core/qsceneinterface.h
index 0a1ac6c26..dd6041e07 100644
--- a/src/core/qsceneinterface.h
+++ b/src/core/qsceneinterface.h
@@ -44,7 +44,7 @@
 
 #include <Qt3DCore/qt3dcore_global.h>
 #include <QObject>
-#include <Qt3DCore/qnodeuuid.h>
+#include <Qt3DCore/qnodeid.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -62,18 +62,18 @@ class QT3DCORESHARED_EXPORT QSceneInterface
 {
 public:
     virtual ~QSceneInterface() {}
-    virtual void addObservable(QObservableInterface *observable, const QNodeUuid &uuid) = 0;
+    virtual void addObservable(QObservableInterface *observable, const QNodeId &uuid) = 0;
     virtual void addObservable(QNode *observable) = 0;
-    virtual void removeObservable(QObservableInterface *observable, const QNodeUuid &uuid) = 0;
+    virtual void removeObservable(QObservableInterface *observable, const QNodeId &uuid) = 0;
     virtual void removeObservable(QNode *observable) = 0;
-    virtual QObservableList lookupObservables(const QNodeUuid &uuid) const = 0;
-    virtual QNode *lookupNode(const QNodeUuid &uuid) const = 0;
-    virtual QNodeUuid nodeIdFromObservable(QObservableInterface *observable) const = 0;
+    virtual QObservableList lookupObservables(const QNodeId &uuid) const = 0;
+    virtual QNode *lookupNode(const QNodeId &uuid) const = 0;
+    virtual QNodeId nodeIdFromObservable(QObservableInterface *observable) const = 0;
     virtual void setArbiter(QChangeArbiter *arbiter) = 0;
 
-    virtual QList<QNodeUuid> entitiesForComponent(const QNodeUuid &componentUuid) const = 0;
-    virtual void addEntityForComponent(const QNodeUuid &componentUuid, const QNodeUuid &entityUuid) = 0;
-    virtual void removeEntityForComponent(const QNodeUuid &componentUuid, const QNodeUuid &entityUuid) = 0;
+    virtual QList<QNodeId> entitiesForComponent(const QNodeId &componentUuid) const = 0;
+    virtual void addEntityForComponent(const QNodeId &componentUuid, const QNodeId &entityUuid) = 0;
+    virtual void removeEntityForComponent(const QNodeId &componentUuid, const QNodeId &entityUuid) = 0;
 };
 
 } // Qt3D
diff --git a/src/input/assignkeyboardfocusjob.cpp b/src/input/assignkeyboardfocusjob.cpp
index 8d7614dcd..4d356cbd6 100644
--- a/src/input/assignkeyboardfocusjob.cpp
+++ b/src/input/assignkeyboardfocusjob.cpp
@@ -51,7 +51,7 @@ namespace Qt3D {
 
 namespace Input {
 
-AssignKeyboardFocusJob::AssignKeyboardFocusJob(const QNodeUuid &controller)
+AssignKeyboardFocusJob::AssignKeyboardFocusJob(const QNodeId &controller)
     : QAspectJob()
     , m_inputHandler(Q_NULLPTR)
     , m_keyboardController(controller)
diff --git a/src/input/assignkeyboardfocusjob_p.h b/src/input/assignkeyboardfocusjob_p.h
index 094d9c7a5..f4807c9e8 100644
--- a/src/input/assignkeyboardfocusjob_p.h
+++ b/src/input/assignkeyboardfocusjob_p.h
@@ -43,7 +43,7 @@
 #define QT3D_INPUT_ASSIGNKEYBOARDFOCUSJOB_P_H
 
 #include <Qt3DCore/qaspectjob.h>
-#include <Qt3DCore/qnodeuuid.h>
+#include <Qt3DCore/qnodeid.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -56,13 +56,13 @@ class InputHandler;
 class AssignKeyboardFocusJob : public QAspectJob
 {
 public:
-    explicit AssignKeyboardFocusJob(const QNodeUuid &controller);
+    explicit AssignKeyboardFocusJob(const QNodeId &controller);
     void setInputHandler(InputHandler *handler);
     void run() Q_DECL_OVERRIDE;
 
 private:
     InputHandler *m_inputHandler;
-    const QNodeUuid m_keyboardController;
+    const QNodeId m_keyboardController;
 };
 
 } // Input
diff --git a/src/input/inputmanagers_p.h b/src/input/inputmanagers_p.h
index 923fb3c04..6f0584c94 100644
--- a/src/input/inputmanagers_p.h
+++ b/src/input/inputmanagers_p.h
@@ -56,7 +56,7 @@ namespace Input {
 
 class KeyboardInputManager : public QResourceManager<
         KeyboardInput,
-        QNodeUuid,
+        QNodeId,
         16,
         Qt3D::ArrayAllocatingPolicy>
 {
@@ -66,7 +66,7 @@ public:
 
 class KeyboardControllerManager : public QResourceManager<
         KeyboardController,
-        QNodeUuid,
+        QNodeId,
         8,
         Qt3D::ArrayAllocatingPolicy>
 {
diff --git a/src/input/keyboardcontroller.cpp b/src/input/keyboardcontroller.cpp
index c4d6a4511..57a242028 100644
--- a/src/input/keyboardcontroller.cpp
+++ b/src/input/keyboardcontroller.cpp
@@ -62,7 +62,7 @@ void KeyboardController::updateFromPeer(QNode *)
 {
 }
 
-void KeyboardController::requestFocusForInput(const QNodeUuid &inputId)
+void KeyboardController::requestFocusForInput(const QNodeId &inputId)
 {
     // Saves the last inputId, this will then be used in an Aspect Job to determine which
     // input will have the focus. This in turn will call KeyboardInput::setFocus which will
@@ -75,7 +75,7 @@ void KeyboardController::setInputHandler(InputHandler *handler)
     m_inputHandler = handler;
 }
 
-void KeyboardController::addKeyboardInput(const QNodeUuid &input)
+void KeyboardController::addKeyboardInput(const QNodeId &input)
 {
     if (!m_keyboardInputs.contains(input)) {
         m_keyboardInputs.append(input);
@@ -83,13 +83,13 @@ void KeyboardController::addKeyboardInput(const QNodeUuid &input)
     }
 }
 
-void KeyboardController::removeKeyboardInput(const QNodeUuid &input)
+void KeyboardController::removeKeyboardInput(const QNodeId &input)
 {
     m_keyboardInputs.removeAll(input);
     m_keyboardInputHandles.removeAll(m_inputHandler->keyboardInputManager()->lookupHandle(input));
 }
 
-void KeyboardController::setCurrentFocusItem(const QNodeUuid &input)
+void KeyboardController::setCurrentFocusItem(const QNodeId &input)
 {
     m_currentFocusItem = input;
 }
diff --git a/src/input/keyboardcontroller_p.h b/src/input/keyboardcontroller_p.h
index 92717964a..1ba9cf393 100644
--- a/src/input/keyboardcontroller_p.h
+++ b/src/input/keyboardcontroller_p.h
@@ -43,7 +43,7 @@
 #define QT3D_INPUT_KEYBOARDCONTROLLER_P_H
 
 #include <Qt3DCore/qbackendnode.h>
-#include <Qt3DCore/qnodeuuid.h>
+#include <Qt3DCore/qnodeid.h>
 #include <Qt3DInput/private/handle_types_p.h>
 
 QT_BEGIN_NAMESPACE
@@ -59,17 +59,17 @@ class KeyboardController : public QBackendNode
 public:
     KeyboardController();
     void updateFromPeer(QNode *peer) Q_DECL_OVERRIDE;
-    void requestFocusForInput(const QNodeUuid &inputId);
+    void requestFocusForInput(const QNodeId &inputId);
     void setInputHandler(InputHandler *handler);
 
-    void addKeyboardInput(const QNodeUuid &input);
-    void removeKeyboardInput(const QNodeUuid &input);
+    void addKeyboardInput(const QNodeId &input);
+    void removeKeyboardInput(const QNodeId &input);
 
-    void setCurrentFocusItem(const QNodeUuid &input);
+    void setCurrentFocusItem(const QNodeId &input);
 
-    inline QNodeUuid currentFocusItem() const { return m_currentFocusItem; }
-    inline QNodeUuid lastKeyboardInputRequester() const { return m_lastRequester; }
-    inline QVector<QNodeUuid> keyboardInputs() const { return m_keyboardInputs; }
+    inline QNodeId currentFocusItem() const { return m_currentFocusItem; }
+    inline QNodeId lastKeyboardInputRequester() const { return m_lastRequester; }
+    inline QVector<QNodeId> keyboardInputs() const { return m_keyboardInputs; }
     inline QVector<HKeyboardInput> keyboardInputsHandles() const { return m_keyboardInputHandles; }
 
 protected:
@@ -77,10 +77,10 @@ protected:
 
 private:
     InputHandler *m_inputHandler;
-    QVector<QNodeUuid> m_keyboardInputs;
+    QVector<QNodeId> m_keyboardInputs;
     QVector<HKeyboardInput> m_keyboardInputHandles;
-    QNodeUuid m_lastRequester;
-    QNodeUuid m_currentFocusItem;
+    QNodeId m_lastRequester;
+    QNodeId m_currentFocusItem;
 };
 
 class KeyboardControllerFunctor : public QBackendNodeFunctor
diff --git a/src/input/keyboardinput.cpp b/src/input/keyboardinput.cpp
index e15b3986c..28d4ee6c5 100644
--- a/src/input/keyboardinput.cpp
+++ b/src/input/keyboardinput.cpp
@@ -71,7 +71,7 @@ void KeyboardInput::updateFromPeer(QNode *peer)
         requestFocus();
 }
 
-QNodeUuid KeyboardInput::keyboardController() const
+QNodeId KeyboardInput::keyboardController() const
 {
     return m_keyboardController;
 }
@@ -110,7 +110,7 @@ void KeyboardInput::sceneChangeEvent(const QSceneChangePtr &e)
     if (e->type() == NodeUpdated) {
         QScenePropertyChangePtr propertyChange = qSharedPointerCast<QScenePropertyChange>(e);
         if (propertyChange->propertyName() == QByteArrayLiteral("controller")) {
-            const QNodeUuid newId = propertyChange->value().value<QNodeUuid>();
+            const QNodeId newId = propertyChange->value().value<QNodeId>();
             if (m_keyboardController != newId) {
                 setController(newId);
                 focusRequest = m_focus;
@@ -130,7 +130,7 @@ void KeyboardInput::requestFocus()
         controller->requestFocusForInput(peerUuid());
 }
 
-void KeyboardInput::setController(const QNodeUuid &controller)
+void KeyboardInput::setController(const QNodeId &controller)
 {
     if (!m_keyboardController.isNull())
         m_inputHandler->keyboardControllerManager()->lookupResource(m_keyboardController)->removeKeyboardInput(peerUuid());
diff --git a/src/input/keyboardinput_p.h b/src/input/keyboardinput_p.h
index 00f8186d7..82c5b5578 100644
--- a/src/input/keyboardinput_p.h
+++ b/src/input/keyboardinput_p.h
@@ -43,7 +43,7 @@
 #define QT3D_INPUT_KEYBOARDINPUT_P_H
 
 #include <Qt3DCore/qbackendnode.h>
-#include <Qt3DCore/qnodeuuid.h>
+#include <Qt3DCore/qnodeid.h>
 #include <Qt3DInput/q3dkeyevent.h>
 
 QT_BEGIN_NAMESPACE
@@ -61,7 +61,7 @@ class KeyboardInput : public QBackendNode
 public:
     KeyboardInput();
     void updateFromPeer(QNode *peer) Q_DECL_OVERRIDE;
-    QNodeUuid keyboardController() const;
+    QNodeId keyboardController() const;
     void setInputHandler(InputHandler *handler);
     void setFocus(bool focus);
     void keyEvent(const Q3DKeyEventPtr &event);
@@ -69,11 +69,11 @@ public:
 protected:
     void sceneChangeEvent(const QSceneChangePtr &e) Q_DECL_OVERRIDE;
     void requestFocus();
-    void setController(const QNodeUuid &controller);
+    void setController(const QNodeId &controller);
 
 private:
     InputHandler *m_inputHandler;
-    QNodeUuid m_keyboardController;
+    QNodeId m_keyboardController;
     bool m_focus;
 };
 
diff --git a/src/input/keyeventdispatcherjob.cpp b/src/input/keyeventdispatcherjob.cpp
index 6d672ba96..e43978b30 100644
--- a/src/input/keyeventdispatcherjob.cpp
+++ b/src/input/keyeventdispatcherjob.cpp
@@ -50,7 +50,7 @@ namespace Qt3D {
 
 namespace Input {
 
-KeyEventDispatcherJob::KeyEventDispatcherJob(const QNodeUuid &input, const QList<QKeyEvent> &events)
+KeyEventDispatcherJob::KeyEventDispatcherJob(const QNodeId &input, const QList<QKeyEvent> &events)
     : QAspectJob()
     , m_inputHandler(Q_NULLPTR)
     , m_keyboardInput(input)
diff --git a/src/input/keyeventdispatcherjob_p.h b/src/input/keyeventdispatcherjob_p.h
index 8dcf37c56..af6d52623 100644
--- a/src/input/keyeventdispatcherjob_p.h
+++ b/src/input/keyeventdispatcherjob_p.h
@@ -43,7 +43,7 @@
 #define QT3D_INPUT_KEYEVENTDISPATCHERJOB_P_H
 
 #include <Qt3DCore/qaspectjob.h>
-#include <Qt3DCore/qnodeuuid.h>
+#include <Qt3DCore/qnodeid.h>
 #include <QKeyEvent>
 
 QT_BEGIN_NAMESPACE
@@ -57,13 +57,13 @@ class InputHandler;
 class KeyEventDispatcherJob : public QAspectJob
 {
 public:
-    explicit KeyEventDispatcherJob(const QNodeUuid &input, const QList<QKeyEvent> &events);
+    explicit KeyEventDispatcherJob(const QNodeId &input, const QList<QKeyEvent> &events);
     void setInputHandler(InputHandler *handler);
     void run() Q_DECL_OVERRIDE;
 
 private:
     InputHandler *m_inputHandler;
-    const QNodeUuid m_keyboardInput;
+    const QNodeId m_keyboardInput;
     const QList<QKeyEvent> m_events;
 };
 
diff --git a/src/input/qkeyboardcontroller.cpp b/src/input/qkeyboardcontroller.cpp
index d221bf7df..237517108 100644
--- a/src/input/qkeyboardcontroller.cpp
+++ b/src/input/qkeyboardcontroller.cpp
@@ -74,7 +74,7 @@ void QKeyboardController::sceneChangeEvent(const QSceneChangePtr &change)
 {
     QBackendScenePropertyChangePtr e = qSharedPointerCast<QBackendScenePropertyChange>(change);
     if (e->type() == NodeUpdated && e->propertyName() == QByteArrayLiteral("activeInput")) {
-        QNodeUuid activeInputId = e->value().value<QNodeUuid>();
+        QNodeId activeInputId = e->value().value<QNodeId>();
         setActiveInput(qobject_cast<QKeyboardInput *>(scene()->lookupNode(activeInputId)));
     }
 }
diff --git a/src/render/backend/attachmentpack_p.h b/src/render/backend/attachmentpack_p.h
index 4172020e6..919788237 100644
--- a/src/render/backend/attachmentpack_p.h
+++ b/src/render/backend/attachmentpack_p.h
@@ -57,7 +57,7 @@ struct Attachment
     QString m_name;
     int m_mipLevel;
     int m_layer;
-    QNodeUuid m_textureUuid;
+    QNodeId m_textureUuid;
     QRenderAttachment::RenderAttachmentType m_type;
     QRenderAttachment::CubeMapFace m_face;
 };
diff --git a/src/render/backend/framegraph/cameraselectornode.cpp b/src/render/backend/framegraph/cameraselectornode.cpp
index b63533eb9..daf68d667 100644
--- a/src/render/backend/framegraph/cameraselectornode.cpp
+++ b/src/render/backend/framegraph/cameraselectornode.cpp
@@ -62,7 +62,7 @@ CameraSelector::CameraSelector()
 void CameraSelector::updateFromPeer(QNode *peer)
 {
     QCameraSelector *selector = static_cast<QCameraSelector *>(peer);
-    m_cameraUuid = QNodeUuid();
+    m_cameraUuid = QNodeId();
     if (selector->camera() != Q_NULLPTR)
         m_cameraUuid = selector->camera()->uuid();
 }
@@ -73,12 +73,12 @@ void CameraSelector::sceneChangeEvent(const QSceneChangePtr &e)
     if (e->type() == NodeUpdated) {
         QScenePropertyChangePtr propertyChange = qSharedPointerCast<QScenePropertyChange>(e);
         if (propertyChange->propertyName() == QByteArrayLiteral("camera")) {
-            m_cameraUuid = propertyChange->value().value<QNodeUuid>();
+            m_cameraUuid = propertyChange->value().value<QNodeId>();
         }
     }
 }
 
-QNodeUuid CameraSelector::cameraUuid() const
+QNodeId CameraSelector::cameraUuid() const
 {
     return m_cameraUuid;
 }
diff --git a/src/render/backend/framegraph/cameraselectornode_p.h b/src/render/backend/framegraph/cameraselectornode_p.h
index 62352c258..10dab2fae 100644
--- a/src/render/backend/framegraph/cameraselectornode_p.h
+++ b/src/render/backend/framegraph/cameraselectornode_p.h
@@ -43,7 +43,7 @@
 #define QT3D_RENDER_CAMERASELECTOR_H
 
 #include <Qt3DRenderer/private/framegraphnode_p.h>
-#include <Qt3DCore/qnodeuuid.h>
+#include <Qt3DCore/qnodeid.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -64,10 +64,10 @@ public:
     void updateFromPeer(QNode *peer) Q_DECL_OVERRIDE;
 
     void sceneChangeEvent(const QSceneChangePtr &e) Q_DECL_OVERRIDE;
-    QNodeUuid cameraUuid() const;
+    QNodeId cameraUuid() const;
 
 private:
-    QNodeUuid m_cameraUuid;
+    QNodeId m_cameraUuid;
 };
 
 } // namespace Render
diff --git a/src/render/backend/framegraph/renderpassfilternode.cpp b/src/render/backend/framegraph/renderpassfilternode.cpp
index 9eac9a155..74c153fa8 100644
--- a/src/render/backend/framegraph/renderpassfilternode.cpp
+++ b/src/render/backend/framegraph/renderpassfilternode.cpp
@@ -62,7 +62,7 @@ void RenderPassFilter::updateFromPeer(QNode *peer)
         appendFilter(criterion);
 }
 
-QList<QNodeUuid> RenderPassFilter::filters() const
+QList<QNodeId> RenderPassFilter::filters() const
 {
     return m_filters;
 }
@@ -73,7 +73,7 @@ void RenderPassFilter::appendFilter(QAnnotation *criterion)
         m_filters.append(criterion->uuid());
 }
 
-void RenderPassFilter::removeFilter(const QNodeUuid &criterionId)
+void RenderPassFilter::removeFilter(const QNodeId &criterionId)
 {
     m_filters.removeOne(criterionId);
 }
@@ -90,7 +90,7 @@ void RenderPassFilter::sceneChangeEvent(const QSceneChangePtr &e)
     case NodeRemoved: {
         QScenePropertyChangePtr propertyChange = qSharedPointerCast<QScenePropertyChange>(e);
         if (propertyChange->propertyName() == QByteArrayLiteral("include"))
-            removeFilter(propertyChange->value().value<QNodeUuid>());
+            removeFilter(propertyChange->value().value<QNodeId>());
     }
         break;
     default:
diff --git a/src/render/backend/framegraph/renderpassfilternode_p.h b/src/render/backend/framegraph/renderpassfilternode_p.h
index 819338e76..96b20692a 100644
--- a/src/render/backend/framegraph/renderpassfilternode_p.h
+++ b/src/render/backend/framegraph/renderpassfilternode_p.h
@@ -64,13 +64,13 @@ public:
     RenderPassFilter();
 
     void updateFromPeer(QNode *peer) Q_DECL_OVERRIDE;
-    QList<QNodeUuid> filters() const;
+    QList<QNodeId> filters() const;
     void appendFilter(QAnnotation *criterion);
-    void removeFilter(const QNodeUuid &criterionId);
+    void removeFilter(const QNodeId &criterionId);
     void sceneChangeEvent(const QSceneChangePtr &e) Q_DECL_OVERRIDE;
 
 private:
-    QList<QNodeUuid> m_filters;
+    QList<QNodeId> m_filters;
 };
 
 } // namespace Render
diff --git a/src/render/backend/framegraph/rendertargetselectornode.cpp b/src/render/backend/framegraph/rendertargetselectornode.cpp
index 963c49ba7..8e80f3e17 100644
--- a/src/render/backend/framegraph/rendertargetselectornode.cpp
+++ b/src/render/backend/framegraph/rendertargetselectornode.cpp
@@ -61,7 +61,7 @@ RenderTargetSelector::RenderTargetSelector() :
 void RenderTargetSelector::updateFromPeer(QNode *peer)
 {
     QRenderTargetSelector *selector = static_cast<QRenderTargetSelector *>(peer);
-    m_renderTargetUuid = QNodeUuid();
+    m_renderTargetUuid = QNodeId();
     if (selector->target() != Q_NULLPTR)
         m_renderTargetUuid = selector->target()->uuid();
 }
@@ -72,11 +72,11 @@ void RenderTargetSelector::sceneChangeEvent(const QSceneChangePtr &e)
     if (e->type() == NodeUpdated) {
         QScenePropertyChangePtr propertyChange = qSharedPointerCast<QScenePropertyChange>(e);
         if (propertyChange->propertyName() == QByteArrayLiteral("target"))
-            m_renderTargetUuid = propertyChange->value().value<QNodeUuid>();
+            m_renderTargetUuid = propertyChange->value().value<QNodeId>();
     }
 }
 
-QNodeUuid RenderTargetSelector::renderTargetUuid() const
+QNodeId RenderTargetSelector::renderTargetUuid() const
 {
     return m_renderTargetUuid;
 }
diff --git a/src/render/backend/framegraph/rendertargetselectornode_p.h b/src/render/backend/framegraph/rendertargetselectornode_p.h
index 69914da1b..178984192 100644
--- a/src/render/backend/framegraph/rendertargetselectornode_p.h
+++ b/src/render/backend/framegraph/rendertargetselectornode_p.h
@@ -59,10 +59,10 @@ public:
 
     void updateFromPeer(QNode *peer) Q_DECL_OVERRIDE;
     void sceneChangeEvent(const QSceneChangePtr &e) Q_DECL_OVERRIDE;
-    QNodeUuid renderTargetUuid() const;
+    QNodeId renderTargetUuid() const;
 
 private:
-    QNodeUuid m_renderTargetUuid;
+    QNodeId m_renderTargetUuid;
 };
 
 } // Render
diff --git a/src/render/backend/framegraph/sortmethod.cpp b/src/render/backend/framegraph/sortmethod.cpp
index cd5fdd542..342005eaa 100644
--- a/src/render/backend/framegraph/sortmethod.cpp
+++ b/src/render/backend/framegraph/sortmethod.cpp
@@ -76,7 +76,7 @@ void SortMethod::sceneChangeEvent(const QSceneChangePtr &e)
     }
 }
 
-QList<QNodeUuid> SortMethod::criteria() const
+QList<QNodeId> SortMethod::criteria() const
 {
     return m_criteria;
 }
diff --git a/src/render/backend/framegraph/sortmethod_p.h b/src/render/backend/framegraph/sortmethod_p.h
index 4a2e5e5b0..d85647f85 100644
--- a/src/render/backend/framegraph/sortmethod_p.h
+++ b/src/render/backend/framegraph/sortmethod_p.h
@@ -59,10 +59,10 @@ public:
     void updateFromPeer(QNode *peer) Q_DECL_OVERRIDE;
     void sceneChangeEvent(const QSceneChangePtr &e) Q_DECL_OVERRIDE;
 
-    QList<QNodeUuid> criteria() const;
+    QList<QNodeId> criteria() const;
 
 private:
-    QList<QNodeUuid> m_criteria;
+    QList<QNodeId> m_criteria;
 };
 
 } // Render
diff --git a/src/render/backend/framegraph/techniquefilternode.cpp b/src/render/backend/framegraph/techniquefilternode.cpp
index 775287833..602b3673c 100644
--- a/src/render/backend/framegraph/techniquefilternode.cpp
+++ b/src/render/backend/framegraph/techniquefilternode.cpp
@@ -63,7 +63,7 @@ void TechniqueFilter::updateFromPeer(QNode *peer)
         appendFilter(criterion);
 }
 
-QList<QNodeUuid> TechniqueFilter::filters() const
+QList<QNodeId> TechniqueFilter::filters() const
 {
     return m_filters;
 }
@@ -74,7 +74,7 @@ void TechniqueFilter::appendFilter(QAnnotation *criterion)
         m_filters.append(criterion->uuid());
 }
 
-void TechniqueFilter::removeFilter(const QNodeUuid &criterionId)
+void TechniqueFilter::removeFilter(const QNodeId &criterionId)
 {
     m_filters.removeOne(criterionId);
 }
@@ -91,7 +91,7 @@ void TechniqueFilter::sceneChangeEvent(const QSceneChangePtr &e)
     case NodeRemoved: {
         QScenePropertyChangePtr propertyChange = qSharedPointerCast<QScenePropertyChange>(e);
         if (propertyChange->propertyName() == QByteArrayLiteral("require"))
-            removeFilter(propertyChange->value().value<QNodeUuid>());
+            removeFilter(propertyChange->value().value<QNodeId>());
     }
         break;
     default:
diff --git a/src/render/backend/framegraph/techniquefilternode_p.h b/src/render/backend/framegraph/techniquefilternode_p.h
index eeb50b66e..d4f1ff7bc 100644
--- a/src/render/backend/framegraph/techniquefilternode_p.h
+++ b/src/render/backend/framegraph/techniquefilternode_p.h
@@ -67,14 +67,14 @@ public:
     TechniqueFilter();
     void updateFromPeer(QNode *peer) Q_DECL_OVERRIDE;
 
-    QList<QNodeUuid> filters() const;
+    QList<QNodeId> filters() const;
     void sceneChangeEvent(const QSceneChangePtr &e) Q_DECL_OVERRIDE;
 
 private:
     void appendFilter(QAnnotation *criterion);
-    void removeFilter(const QNodeUuid &criterionId);
+    void removeFilter(const QNodeId &criterionId);
 
-    QList<QNodeUuid> m_filters;
+    QList<QNodeId> m_filters;
 };
 
 } // Render
diff --git a/src/render/backend/jobs/loadmeshdatajob.cpp b/src/render/backend/jobs/loadmeshdatajob.cpp
index 0e79c2d90..d98a56bab 100644
--- a/src/render/backend/jobs/loadmeshdatajob.cpp
+++ b/src/render/backend/jobs/loadmeshdatajob.cpp
@@ -56,7 +56,7 @@ QT_BEGIN_NAMESPACE
 namespace Qt3D {
 namespace Render {
 
-LoadMeshDataJob::LoadMeshDataJob(QAbstractMeshFunctorPtr functor, const QNodeUuid &meshUuid)
+LoadMeshDataJob::LoadMeshDataJob(QAbstractMeshFunctorPtr functor, const QNodeId &meshUuid)
     : QAspectJob()
     , m_meshUuid(meshUuid)
     , m_functor(functor)
diff --git a/src/render/backend/jobs/loadmeshdatajob.h b/src/render/backend/jobs/loadmeshdatajob.h
index c2a46e259..d59027b38 100644
--- a/src/render/backend/jobs/loadmeshdatajob.h
+++ b/src/render/backend/jobs/loadmeshdatajob.h
@@ -42,7 +42,7 @@
 #ifndef QT3D_RENDER_LOADMESHDATAJOB_H
 #define QT3D_RENDER_LOADMESHDATAJOB_H
 
-#include <Qt3DCore/qnodeuuid.h>
+#include <Qt3DCore/qnodeid.h>
 #include <Qt3DCore/qaspectjob.h>
 #include <Qt3DCore/qhandle.h>
 #include <Qt3DRenderer/qmeshdata.h>
@@ -60,13 +60,13 @@ class Renderer;
 class LoadMeshDataJob : public Qt3D::QAspectJob
 {
 public:
-    LoadMeshDataJob(QAbstractMeshFunctorPtr functor, const QNodeUuid &meshUuid);
+    LoadMeshDataJob(QAbstractMeshFunctorPtr functor, const QNodeId &meshUuid);
     void setRenderer(Renderer *renderer) { m_renderer = renderer; }
 protected:
     void run() Q_DECL_OVERRIDE;
 
 private:
-    QNodeUuid m_meshUuid;
+    QNodeId m_meshUuid;
     QAbstractMeshFunctorPtr m_functor;
     Renderer *m_renderer;
 };
diff --git a/src/render/backend/jobs/loadscenejob.cpp b/src/render/backend/jobs/loadscenejob.cpp
index be399c465..6e21543da 100644
--- a/src/render/backend/jobs/loadscenejob.cpp
+++ b/src/render/backend/jobs/loadscenejob.cpp
@@ -51,7 +51,7 @@ namespace Qt3D {
 
 namespace Render {
 
-LoadSceneJob::LoadSceneJob(const QString &source, const QNodeUuid &m_sceneComponent)
+LoadSceneJob::LoadSceneJob(const QString &source, const QNodeId &m_sceneComponent)
     : QAspectJob()
     , m_renderer(Q_NULLPTR)
     , m_source(source)
diff --git a/src/render/backend/jobs/loadscenejob.h b/src/render/backend/jobs/loadscenejob.h
index 130259faa..d9a516cee 100644
--- a/src/render/backend/jobs/loadscenejob.h
+++ b/src/render/backend/jobs/loadscenejob.h
@@ -43,7 +43,7 @@
 #define QT3D_RENDER_LOADSCENEJOB_H
 
 #include <Qt3DCore/qaspectjob.h>
-#include <Qt3DCore/qnodeuuid.h>
+#include <Qt3DCore/qnodeid.h>
 #include <QSharedPointer>
 
 QT_BEGIN_NAMESPACE
@@ -57,7 +57,7 @@ class Renderer;
 class LoadSceneJob : public Qt3D::QAspectJob
 {
 public:
-    explicit LoadSceneJob(const QString &source, const QNodeUuid &sceneComponent);
+    explicit LoadSceneJob(const QString &source, const QNodeId &sceneComponent);
     void setRenderer(Renderer *renderer) { m_renderer = renderer; }
 
 protected:
@@ -66,7 +66,7 @@ protected:
 private:
     Renderer *m_renderer;
     QString m_source;
-    QNodeUuid m_sceneComponent;
+    QNodeId m_sceneComponent;
 };
 
 typedef QSharedPointer<LoadSceneJob> LoadSceneJobPtr;
diff --git a/src/render/backend/jobs/renderviewjobutils.cpp b/src/render/backend/jobs/renderviewjobutils.cpp
index f3777c3da..1e0f042ad 100644
--- a/src/render/backend/jobs/renderviewjobutils.cpp
+++ b/src/render/backend/jobs/renderviewjobutils.cpp
@@ -123,7 +123,7 @@ void setRenderViewConfigFromFrameGraphLeafNode(RenderView *rv, const FrameGraphN
 
         case FrameGraphNode::RenderTarget: {
             // Can be set once and we take render target nearest to the leaf node
-            QNodeUuid renderTargetUid = static_cast<const RenderTargetSelector *>(node)->renderTargetUuid();
+            QNodeId renderTargetUid = static_cast<const RenderTargetSelector *>(node)->renderTargetUuid();
             HTarget renderTargetHandle = renderer->renderTargetManager()->lookupHandle(renderTargetUid);
             if (rv->renderTargetHandle().isNull()) {
                 rv->setRenderTargetHandle(renderTargetHandle);
@@ -131,7 +131,7 @@ void setRenderViewConfigFromFrameGraphLeafNode(RenderView *rv, const FrameGraphN
                 RenderTarget *renderTarget = renderer->renderTargetManager()->data(renderTargetHandle);
                 if (renderTarget) {
                     // Add renderTarget Handle and build renderCommand AttachmentPack
-                    Q_FOREACH (const QNodeUuid &attachmentId, renderTarget->renderAttachments()) {
+                    Q_FOREACH (const QNodeId &attachmentId, renderTarget->renderAttachments()) {
                         RenderAttachment *attachment = renderer->attachmentManager()->lookupResource(attachmentId);
                         if (attachment)
                             rv->addRenderAttachment(attachment->attachment());
@@ -221,7 +221,7 @@ RenderTechnique *findTechniqueForEffect(Renderer *renderer,
         return Q_NULLPTR;
 
     // Iterate through the techniques in the effect
-    Q_FOREACH (const QNodeUuid &techniqueId, effect->techniques()) {
+    Q_FOREACH (const QNodeId &techniqueId, effect->techniques()) {
         RenderTechnique *technique = renderer->techniqueManager()->lookupResource(techniqueId);
 
         if (!technique)
@@ -243,11 +243,11 @@ RenderTechnique *findTechniqueForEffect(Renderer *renderer,
 
             // Iterate through the filter criteria and for each one search for a criteria on the
             // technique that satisfies it
-            Q_FOREACH (const QNodeUuid &filterAnnotationId, techniqueFilter->filters()) {
+            Q_FOREACH (const QNodeId &filterAnnotationId, techniqueFilter->filters()) {
                 foundMatch = false;
                 RenderAnnotation *filterAnnotation = renderer->criterionManager()->lookupResource(filterAnnotationId);
 
-                Q_FOREACH (const QNodeUuid &techniqueAnnotationId, technique->annotations()) {
+                Q_FOREACH (const QNodeId &techniqueAnnotationId, technique->annotations()) {
                     RenderAnnotation *techniqueAnnotation = renderer->criterionManager()->lookupResource(techniqueAnnotationId);
                     if ((foundMatch = (*techniqueAnnotation == *filterAnnotation)))
                         break;
@@ -279,7 +279,7 @@ QVector<RenderRenderPass *> findRenderPassesForTechnique(Renderer *renderer,
 
     QVector<RenderRenderPass *> passes;
     passes.reserve(3); // We rarely get more than 2 or 3 passes
-    Q_FOREACH (const QNodeUuid &passId, technique->renderPasses()) {
+    Q_FOREACH (const QNodeId &passId, technique->renderPasses()) {
         RenderRenderPass *renderPass = renderer->renderPassManager()->lookupResource(passId);
 
         if (renderPass) {
@@ -290,11 +290,11 @@ QVector<RenderRenderPass *> findRenderPassesForTechnique(Renderer *renderer,
             if (!foundMatch && renderPass->annotations().size() >= passFilter->filters().size()) {
 
                 // Iterate through the filter criteria and look for render passes with criteria that satisfy them
-                Q_FOREACH (const QNodeUuid &filterAnnotationId, passFilter->filters()) {
+                Q_FOREACH (const QNodeId &filterAnnotationId, passFilter->filters()) {
                     foundMatch = false;
                     RenderAnnotation *filterAnnotation = renderer->criterionManager()->lookupResource(filterAnnotationId);
 
-                    Q_FOREACH (const QNodeUuid &passAnnotationId, renderPass->annotations()) {
+                    Q_FOREACH (const QNodeId &passAnnotationId, renderPass->annotations()) {
                         RenderAnnotation *passAnnotation = renderer->criterionManager()->lookupResource(passAnnotationId);
                         if ((foundMatch = (*passAnnotation == *filterAnnotation)))
                             break;
@@ -318,9 +318,9 @@ QVector<RenderRenderPass *> findRenderPassesForTechnique(Renderer *renderer,
 }
 
 static void addParametersForIds(QHash<QString, QVariant> *params, ParameterManager *manager,
-                                const QList<QNodeUuid> &parameterIds)
+                                const QList<QNodeId> &parameterIds)
 {
-    Q_FOREACH (const QNodeUuid &paramId, parameterIds) {
+    Q_FOREACH (const QNodeId &paramId, parameterIds) {
         RenderParameter *param = manager->lookupResource(paramId);
         if (param != Q_NULLPTR)
             params->insert(param->name(), param->value());
diff --git a/src/render/backend/managers_p.h b/src/render/backend/managers_p.h
index 1e9ac4611..3faaf65a2 100644
--- a/src/render/backend/managers_p.h
+++ b/src/render/backend/managers_p.h
@@ -72,7 +72,7 @@ namespace Render {
 
 class AttachmentManager : public QResourceManager<
         RenderAttachment,
-        QNodeUuid,
+        QNodeId,
         16,
         Qt3D::ArrayAllocatingPolicy,
         Qt3D::ObjectLevelLockingPolicy>
@@ -83,7 +83,7 @@ public:
 
 class CameraManager : public QResourceManager<
         RenderCameraLens,
-        QNodeUuid,
+        QNodeId,
         8,
         Qt3D::ArrayAllocatingPolicy>
 {
@@ -93,7 +93,7 @@ public:
 
 class CriterionManager : public QResourceManager<
         RenderAnnotation,
-        QNodeUuid,
+        QNodeId,
         16,
         Qt3D::ArrayAllocatingPolicy,
         Qt3D::ObjectLevelLockingPolicy>
@@ -105,7 +105,7 @@ public:
 
 class EffectManager : public QResourceManager<
         RenderEffect,
-        QNodeUuid,
+        QNodeId,
         16,
         Qt3D::ArrayAllocatingPolicy,
         Qt3D::ObjectLevelLockingPolicy>
@@ -114,7 +114,7 @@ public:
     EffectManager() {}
 };
 
-class EntityManager : public QResourceManager<RenderEntity, QNodeUuid, 16>
+class EntityManager : public QResourceManager<RenderEntity, QNodeId, 16>
 {
 public:
     EntityManager() {}
@@ -122,7 +122,7 @@ public:
 
 class FrameGraphManager : public QResourceManager<
         FrameGraphNode *,
-        QNodeUuid,
+        QNodeId,
         8,
         Qt3D::ArrayAllocatingPolicy>
 {
@@ -132,7 +132,7 @@ public:
 
 class LayerManager : public QResourceManager<
         RenderLayer,
-        QNodeUuid,
+        QNodeId,
         16,
         Qt3D::ArrayAllocatingPolicy,
         Qt3D::ObjectLevelLockingPolicy>
@@ -143,7 +143,7 @@ public:
 
 class LightManager : public QResourceManager<
         RenderLight,
-        QNodeUuid,
+        QNodeId,
         16,
         Qt3D::ArrayAllocatingPolicy,
         Qt3D::ObjectLevelLockingPolicy>
@@ -154,7 +154,7 @@ public:
 
 class MaterialManager : public QResourceManager<
         RenderMaterial,
-        QNodeUuid,
+        QNodeId,
         16,
         Qt3D::ArrayAllocatingPolicy,
         Qt3D::ObjectLevelLockingPolicy>
@@ -163,7 +163,7 @@ public:
     MaterialManager() {}
 };
 
-class MatrixManager : public QResourceManager<QMatrix4x4, QNodeUuid, 16>
+class MatrixManager : public QResourceManager<QMatrix4x4, QNodeId, 16>
 {
 public:
     MatrixManager() {}
@@ -171,7 +171,7 @@ public:
 
 class MeshManager : public QResourceManager<
         RenderMesh,
-        QNodeUuid,
+        QNodeId,
         16,
         Qt3D::ArrayAllocatingPolicy,
         Qt3D::ObjectLevelLockingPolicy>
@@ -182,7 +182,7 @@ public:
 
 class ShaderManager : public QResourceManager<
         RenderShader,
-        QNodeUuid,
+        QNodeId,
         16,
         Qt3D::ArrayAllocatingPolicy,
         Qt3D::ObjectLevelLockingPolicy>
@@ -193,7 +193,7 @@ public:
 
 class SortCriterionManager : public QResourceManager<
         SortCriterion,
-        QNodeUuid,
+        QNodeId,
         8,
         Qt3D::ArrayAllocatingPolicy,
         Qt3D::ObjectLevelLockingPolicy>
@@ -204,7 +204,7 @@ public:
 
 class TechniqueManager : public QResourceManager<
         RenderTechnique,
-        QNodeUuid,
+        QNodeId,
         16,
         Qt3D::ArrayAllocatingPolicy,
         Qt3D::ObjectLevelLockingPolicy>
@@ -215,7 +215,7 @@ public:
 
 class TextureManager : public QResourceManager<
         RenderTexture,
-        QNodeUuid,
+        QNodeId,
         16,
         Qt3D::ArrayAllocatingPolicy,
         Qt3D::ObjectLevelLockingPolicy>
@@ -226,7 +226,7 @@ public:
 
 class TransformManager : public QResourceManager<
         RenderTransform,
-        QNodeUuid,
+        QNodeId,
         16,
         Qt3D::ArrayAllocatingPolicy,
         Qt3D::ObjectLevelLockingPolicy>
@@ -246,7 +246,7 @@ public:
 
 class RenderTargetManager : public QResourceManager<
         RenderTarget,
-        QNodeUuid,
+        QNodeId,
         8,
         Qt3D::ArrayAllocatingPolicy,
         Qt3D::ObjectLevelLockingPolicy>
@@ -257,7 +257,7 @@ public:
 
 class RenderPassManager : public QResourceManager<
         RenderRenderPass,
-        QNodeUuid,
+        QNodeId,
         16,
         Qt3D::ArrayAllocatingPolicy,
         Qt3D::ObjectLevelLockingPolicy>
@@ -269,7 +269,7 @@ public:
 
 class ParameterManager : public QResourceManager<
         RenderParameter,
-        QNodeUuid,
+        QNodeId,
         16,
         Qt3D::ArrayAllocatingPolicy,
         Qt3D::ObjectLevelLockingPolicy>
diff --git a/src/render/backend/meshdatamanager.cpp b/src/render/backend/meshdatamanager.cpp
index 70681649d..13266e5a5 100644
--- a/src/render/backend/meshdatamanager.cpp
+++ b/src/render/backend/meshdatamanager.cpp
@@ -47,16 +47,16 @@ namespace Qt3D {
 namespace Render {
 
 // Called by aspect thread when RenderMesh receive a new functor in syncChanges
-void MeshDataManager::addMeshData(QAbstractMeshFunctorPtr functor, const QNodeUuid &meshUuid)
+void MeshDataManager::addMeshData(QAbstractMeshFunctorPtr functor, const QNodeId &meshUuid)
 {
     m_meshesPending[meshUuid] = functor;
 }
 
 // Called by single thread in QRenderAspect
 // Needs to be protected as we ways call it while addMeshData is called
-QHash<QNodeUuid, QAbstractMeshFunctorPtr> MeshDataManager::meshesPending()
+QHash<QNodeId, QAbstractMeshFunctorPtr> MeshDataManager::meshesPending()
 {
-    QHash<QNodeUuid, QAbstractMeshFunctorPtr> meshFunctors = m_meshesPending;
+    QHash<QNodeId, QAbstractMeshFunctorPtr> meshFunctors = m_meshesPending;
     m_meshesPending.clear();
     return meshFunctors;
 }
diff --git a/src/render/backend/meshdatamanager_p.h b/src/render/backend/meshdatamanager_p.h
index adceb6fab..e7251cca7 100644
--- a/src/render/backend/meshdatamanager_p.h
+++ b/src/render/backend/meshdatamanager_p.h
@@ -52,7 +52,7 @@
 #include <QHash>
 #include <QPair>
 #include <QString>
-#include <Qt3DCore/qnodeuuid.h>
+#include <Qt3DCore/qnodeid.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -60,16 +60,16 @@ namespace Qt3D {
 namespace Render {
 
 class MeshDataManager : public QResourceManager<QMeshData,
-                                                 QNodeUuid,
+                                                 QNodeId,
                                                  16,
                                                  Qt3D::ListAllocatingPolicy,
                                                  Qt3D::ObjectLevelLockingPolicy>
 {
 public:
     MeshDataManager() {}
-    void addMeshData(QAbstractMeshFunctorPtr functor, const QNodeUuid &meshUuid);
+    void addMeshData(QAbstractMeshFunctorPtr functor, const QNodeId &meshUuid);
 
-    QHash<QNodeUuid, QAbstractMeshFunctorPtr> meshesPending();
+    QHash<QNodeId, QAbstractMeshFunctorPtr> meshesPending();
     HMeshData meshDataFromFunctor(QAbstractMeshFunctorPtr functor) const;
     void addMeshDataForFunctor(HMeshData meshDataHandle, QAbstractMeshFunctorPtr functor);
 
@@ -77,7 +77,7 @@ private:
     // List of meshes that we need to schedule jobs to load
     // and calculate bounds for.
 
-    QHash<QNodeUuid, QAbstractMeshFunctorPtr> m_meshesPending;
+    QHash<QNodeId, QAbstractMeshFunctorPtr> m_meshesPending;
     QHash<QAbstractMeshFunctorPtr, HMeshData> m_meshFunctors;
 };
 
diff --git a/src/render/backend/parameterpack.cpp b/src/render/backend/parameterpack.cpp
index 85607e8ce..ee84571db 100644
--- a/src/render/backend/parameterpack.cpp
+++ b/src/render/backend/parameterpack.cpp
@@ -61,21 +61,21 @@ void ParameterPack::clear()
     m_peers.clear();
 }
 
-void ParameterPack::appendParameter(const QNodeUuid &parameterId)
+void ParameterPack::appendParameter(const QNodeId &parameterId)
 {
     if (!m_peers.contains(parameterId)) {
         m_peers.append(parameterId);
     }
 }
 
-void ParameterPack::removeParameter(const QNodeUuid &parameterId)
+void ParameterPack::removeParameter(const QNodeId &parameterId)
 {
     if (m_peers.contains(parameterId)) {
         m_peers.removeOne(parameterId);
     }
 }
 
-QList<QNodeUuid> ParameterPack::parameters() const
+QList<QNodeId> ParameterPack::parameters() const
 {
     return m_peers;
 }
diff --git a/src/render/backend/parameterpack_p.h b/src/render/backend/parameterpack_p.h
index 3358dc6cc..f33864aaf 100644
--- a/src/render/backend/parameterpack_p.h
+++ b/src/render/backend/parameterpack_p.h
@@ -42,7 +42,7 @@
 #ifndef QT3D_RENDER_PARAMETERPACK_H
 #define QT3D_RENDER_PARAMETERPACK_H
 
-#include <Qt3DCore/qnodeuuid.h>
+#include <Qt3DCore/qnodeid.h>
 #include <QList>
 
 QT_BEGIN_NAMESPACE
@@ -57,12 +57,12 @@ public:
     ParameterPack();
     ~ParameterPack();
     void clear();
-    void appendParameter(const QNodeUuid &parameterId);
-    void removeParameter(const QNodeUuid &parameterId);
-    QList<QNodeUuid> parameters() const;
+    void appendParameter(const QNodeId &parameterId);
+    void removeParameter(const QNodeId &parameterId);
+    QList<QNodeId> parameters() const;
 
 private:
-    QList<QNodeUuid> m_peers;
+    QList<QNodeId> m_peers;
 };
 
 } // Render
diff --git a/src/render/backend/qgraphicscontext_p.h b/src/render/backend/qgraphicscontext_p.h
index ed9b09207..d9d68afa1 100644
--- a/src/render/backend/qgraphicscontext_p.h
+++ b/src/render/backend/qgraphicscontext_p.h
@@ -200,7 +200,7 @@ private:
     RenderShader *m_activeShader;
     QHash<RenderShader *, QOpenGLShaderProgram *> m_shaderHash;
     QHash<BufferPtr, QOpenGLBuffer> m_bufferHash;
-    QHash<QNodeUuid, GLuint> m_renderTargets;
+    QHash<QNodeId, GLuint> m_renderTargets;
     QHash<GLuint, QSize> m_renderTargetsSize;
 
     // active textures, indexed by texture unit
diff --git a/src/render/backend/qrenderaspect.cpp b/src/render/backend/qrenderaspect.cpp
index 60cc6ab36..e39e2e565 100644
--- a/src/render/backend/qrenderaspect.cpp
+++ b/src/render/backend/qrenderaspect.cpp
@@ -204,8 +204,8 @@ QVector<QAspectJobPtr> QRenderAspect::jobsToExecute()
     // Create jobs to load in any meshes that are pending
     Q_D(QRenderAspect);
     if (d->m_renderer != Q_NULLPTR) {
-        QHash<QNodeUuid, QAbstractMeshFunctorPtr> meshSources = d->m_renderer->meshDataManager()->meshesPending();
-        Q_FOREACH (const QNodeUuid &meshId, meshSources.keys()) {
+        QHash<QNodeId, QAbstractMeshFunctorPtr> meshSources = d->m_renderer->meshDataManager()->meshesPending();
+        Q_FOREACH (const QNodeId &meshId, meshSources.keys()) {
             Render::LoadMeshDataJobPtr loadMeshJob(new Render::LoadMeshDataJob(meshSources[meshId], meshId));
             loadMeshJob->setRenderer(d->m_renderer);
             jobs.append(loadMeshJob);
diff --git a/src/render/backend/quniformvalue.cpp b/src/render/backend/quniformvalue.cpp
index e3ae1f1a3..c3997a435 100644
--- a/src/render/backend/quniformvalue.cpp
+++ b/src/render/backend/quniformvalue.cpp
@@ -93,7 +93,7 @@ void QUniformPack::setUniform(QString glslName, const QUniformValue *val)
     m_uniforms[glslName] = val;
 }
 
-void QUniformPack::setTexture(QString glslName, const QNodeUuid &texId)
+void QUniformPack::setTexture(QString glslName, const QNodeId &texId)
 {
     for (int t=0; t<m_textures.size(); ++t) {
         if (m_textures[t].glslName != glslName) {
diff --git a/src/render/backend/quniformvalue_p.h b/src/render/backend/quniformvalue_p.h
index c6aecb4a9..99bc8f789 100644
--- a/src/render/backend/quniformvalue_p.h
+++ b/src/render/backend/quniformvalue_p.h
@@ -46,7 +46,7 @@
 #include <QByteArray>
 #include <QVector>
 #include <QOpenGLShaderProgram>
-#include <Qt3DCore/qnodeuuid.h>
+#include <Qt3DCore/qnodeid.h>
 #include <Qt3DRenderer/private/renderlogging_p.h>
 
 // for RenderTexturePtr
@@ -94,12 +94,12 @@ public :
     {
     }
 
-    void setTextureId(const QNodeUuid &id)
+    void setTextureId(const QNodeId &id)
     {
         m_textureId = id;
     }
 
-    QNodeUuid textureId() const { return m_textureId; }
+    QNodeId textureId() const { return m_textureId; }
 
     bool operator ==(const QUniformValue &other) Q_DECL_OVERRIDE
     {
@@ -113,7 +113,7 @@ public :
     void apply(QGraphicsContext *ctx, const ShaderUniform &description) const;
 
 private:
-    QNodeUuid m_textureId;
+    QNodeId m_textureId;
     int m_textureUnit;
 };
 
@@ -123,20 +123,20 @@ public:
     ~QUniformPack();
 
     void setUniform(QString glslName, const QUniformValue *val);
-    void setTexture(QString glslName, const QNodeUuid &id);
+    void setTexture(QString glslName, const QNodeId &id);
 
     const QHash<QString, const QUniformValue* > &uniforms() const { return m_uniforms; }
     QHash<QString, const QUniformValue* > &uniforms() { return m_uniforms; }
 
     struct NamedTexture {
         NamedTexture() {}
-        NamedTexture(QString nm, const QNodeUuid &t) :
+        NamedTexture(QString nm, const QNodeId &t) :
             glslName(nm),
             texId(t)
         { }
 
         QString glslName;
-        QNodeUuid texId;
+        QNodeId texId;
     };
 
     QVector<NamedTexture> textures() const { return m_textures; }
diff --git a/src/render/backend/renderattachment.cpp b/src/render/backend/renderattachment.cpp
index dfc953a47..b097b7917 100644
--- a/src/render/backend/renderattachment.cpp
+++ b/src/render/backend/renderattachment.cpp
@@ -68,7 +68,7 @@ void RenderAttachment::updateFromPeer(QNode *peer)
         m_attachmentData.m_textureUuid = attachment->texture()->uuid();
 }
 
-QNodeUuid RenderAttachment::textureUuid() const
+QNodeId RenderAttachment::textureUuid() const
 {
     return m_attachmentData.m_textureUuid;
 }
@@ -106,7 +106,7 @@ void RenderAttachment::sceneChangeEvent(const QSceneChangePtr &e)
             m_attachmentData.m_type = static_cast<QRenderAttachment::RenderAttachmentType>(propertyChange->value().toInt());
         }
         else if (propertyChange->propertyName() == QByteArrayLiteral("texture")) {
-            m_attachmentData.m_textureUuid = propertyChange->value().value<QNodeUuid>();
+            m_attachmentData.m_textureUuid = propertyChange->value().value<QNodeId>();
         }
         else if (propertyChange->propertyName() == QByteArrayLiteral("mipLevel")) {
             m_attachmentData.m_mipLevel = propertyChange->value().toInt();
diff --git a/src/render/backend/renderattachment_p.h b/src/render/backend/renderattachment_p.h
index 07ad2b0d7..24935b09f 100644
--- a/src/render/backend/renderattachment_p.h
+++ b/src/render/backend/renderattachment_p.h
@@ -45,7 +45,7 @@
 #include <Qt3DRenderer/qrenderattachment.h>
 #include <Qt3DRenderer/private/attachmentpack_p.h>
 #include <Qt3DCore/qbackendnode.h>
-#include <Qt3DCore/qnodeuuid.h>
+#include <Qt3DCore/qnodeid.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -64,7 +64,7 @@ public:
 
     void updateFromPeer(QNode *peer) Q_DECL_OVERRIDE;
 
-    QNodeUuid textureUuid() const;
+    QNodeId textureUuid() const;
     int mipLevel() const;
     int layer() const;
     QString name() const;
@@ -74,7 +74,7 @@ public:
     Attachment attachment() const;
 
 private:
-    QNodeUuid m_attachmentUuid;
+    QNodeId m_attachmentUuid;
     Attachment m_attachmentData;
 };
 
diff --git a/src/render/backend/rendereffect.cpp b/src/render/backend/rendereffect.cpp
index cfae8973e..bad296e01 100644
--- a/src/render/backend/rendereffect.cpp
+++ b/src/render/backend/rendereffect.cpp
@@ -90,16 +90,16 @@ void RenderEffect::sceneChangeEvent(const QSceneChangePtr &e)
 
     case NodeAdded:
         if (propertyChange->propertyName() == QByteArrayLiteral("technique"))
-            appendRenderTechnique(propertyValue.value<QNodeUuid>());
+            appendRenderTechnique(propertyValue.value<QNodeId>());
         else if (propertyChange->propertyName() == QByteArrayLiteral("parameter"))
-            m_parameterPack.appendParameter(propertyValue.value<QNodeUuid>());
+            m_parameterPack.appendParameter(propertyValue.value<QNodeId>());
         break;
 
     case NodeRemoved:
         if (propertyChange->propertyName() == QByteArrayLiteral("technique"))
-            m_techniques.removeOne(propertyValue.value<QNodeUuid>());
+            m_techniques.removeOne(propertyValue.value<QNodeId>());
         else if (propertyChange->propertyName() == QByteArrayLiteral("parameter"))
-            m_parameterPack.removeParameter(propertyValue.value<QNodeUuid>());
+            m_parameterPack.removeParameter(propertyValue.value<QNodeId>());
         break;
 
     default :
@@ -107,18 +107,18 @@ void RenderEffect::sceneChangeEvent(const QSceneChangePtr &e)
     }
 }
 
-void RenderEffect::appendRenderTechnique(const QNodeUuid &technique)
+void RenderEffect::appendRenderTechnique(const QNodeId &technique)
 {
     if (!m_techniques.contains(technique))
         m_techniques.append(technique);
 }
 
-QList<QNodeUuid> RenderEffect::techniques() const
+QList<QNodeId> RenderEffect::techniques() const
 {
     return m_techniques;
 }
 
-QList<QNodeUuid> RenderEffect::parameters() const
+QList<QNodeId> RenderEffect::parameters() const
 {
     return m_parameterPack.parameters();
 }
diff --git a/src/render/backend/rendereffect_p.h b/src/render/backend/rendereffect_p.h
index ab94a0c71..ff5c675f6 100644
--- a/src/render/backend/rendereffect_p.h
+++ b/src/render/backend/rendereffect_p.h
@@ -45,7 +45,7 @@
 #include <Qt3DRenderer/qt3drenderer_global.h>
 #include <Qt3DRenderer/private/parameterpack_p.h>
 #include <Qt3DCore/qbackendnode.h>
-#include <Qt3DCore/qnodeuuid.h>
+#include <Qt3DCore/qnodeid.h>
 #include <QList>
 
 QT_BEGIN_NAMESPACE
@@ -66,13 +66,13 @@ public:
 
     void updateFromPeer(QNode *peer) Q_DECL_OVERRIDE;
     void sceneChangeEvent(const QSceneChangePtr &e);
-    void appendRenderTechnique(const QNodeUuid &t);
+    void appendRenderTechnique(const QNodeId &t);
 
-    QList<QNodeUuid> techniques() const;
-    QList<QNodeUuid> parameters() const;
+    QList<QNodeId> techniques() const;
+    QList<QNodeId> parameters() const;
 
 private:
-    QList<QNodeUuid> m_techniques;
+    QList<QNodeId> m_techniques;
     ParameterPack m_parameterPack;
 };
 
diff --git a/src/render/backend/renderentity.cpp b/src/render/backend/renderentity.cpp
index 0212fdba2..563142caf 100644
--- a/src/render/backend/renderentity.cpp
+++ b/src/render/backend/renderentity.cpp
@@ -131,12 +131,12 @@ void RenderEntity::updateFromPeer(QNode *peer)
     m_worldTransform = m_renderer->worldMatrixManager()->getOrAcquireHandle(peerUuid());
 
     // TO DO: Suboptimal -> Maybe have a Hash<QComponent, QEntityList> instead
-    m_transformComponent = QNodeUuid();
-    m_materialComponent = QNodeUuid();
-    m_meshComponent = QNodeUuid();
-    m_cameraComponent = QNodeUuid();
-    m_layerComponent = QNodeUuid();
-    m_lightComponent = QNodeUuid();
+    m_transformComponent = QNodeId();
+    m_materialComponent = QNodeId();
+    m_meshComponent = QNodeId();
+    m_cameraComponent = QNodeId();
+    m_layerComponent = QNodeId();
+    m_lightComponent = QNodeId();
 
     Q_FOREACH (QComponent *comp, entity->components())
         addComponent(comp);
@@ -245,17 +245,17 @@ void RenderEntity::addComponent(QComponent *component)
 void RenderEntity::removeComponent(QComponent *component)
 {
     if (qobject_cast<QTransform *>(component) != Q_NULLPTR)
-        m_transformComponent = QNodeUuid();
+        m_transformComponent = QNodeId();
     else if (qobject_cast<QAbstractMesh *>(component) != Q_NULLPTR)
-        m_meshComponent = QNodeUuid();
+        m_meshComponent = QNodeId();
     else if (qobject_cast<QCameraLens *>(component) != Q_NULLPTR)
-        m_cameraComponent = QNodeUuid();
+        m_cameraComponent = QNodeId();
     else if (qobject_cast<QLayer *>(component) != Q_NULLPTR)
-        m_layerComponent = QNodeUuid();
+        m_layerComponent = QNodeId();
     else if (qobject_cast<QAbstractLight *>(component) != Q_NULLPTR)
-        m_lightComponent = QNodeUuid();
+        m_lightComponent = QNodeId();
     else if (qobject_cast<QMaterial *>(component) != Q_NULLPTR)
-        m_materialComponent = QNodeUuid();
+        m_materialComponent = QNodeId();
 }
 
 template<>
@@ -331,22 +331,22 @@ RenderTransform *RenderEntity::renderComponent<RenderTransform>() const
 }
 
 template<>
-QNodeUuid RenderEntity::componentUuid<RenderTransform>() const { return m_transformComponent; }
+QNodeId RenderEntity::componentUuid<RenderTransform>() const { return m_transformComponent; }
 
 template<>
-QNodeUuid RenderEntity::componentUuid<RenderCameraLens>() const { return m_cameraComponent; }
+QNodeId RenderEntity::componentUuid<RenderCameraLens>() const { return m_cameraComponent; }
 
 template<>
-QNodeUuid RenderEntity::componentUuid<RenderLayer>() const { return m_layerComponent; }
+QNodeId RenderEntity::componentUuid<RenderLayer>() const { return m_layerComponent; }
 
 template<>
-QNodeUuid RenderEntity::componentUuid<RenderMaterial>() const { return m_materialComponent; }
+QNodeId RenderEntity::componentUuid<RenderMaterial>() const { return m_materialComponent; }
 
 template<>
-QNodeUuid RenderEntity::componentUuid<RenderLight>() const { return m_lightComponent; }
+QNodeId RenderEntity::componentUuid<RenderLight>() const { return m_lightComponent; }
 
 template<>
-QNodeUuid RenderEntity::componentUuid<RenderMesh>() const { return m_meshComponent; }
+QNodeId RenderEntity::componentUuid<RenderMesh>() const { return m_meshComponent; }
 
 RenderEntityFunctor::RenderEntityFunctor(Renderer *renderer)
     : m_renderer(renderer)
diff --git a/src/render/backend/renderentity_p.h b/src/render/backend/renderentity_p.h
index 6461814d0..296bde240 100644
--- a/src/render/backend/renderentity_p.h
+++ b/src/render/backend/renderentity_p.h
@@ -46,7 +46,7 @@
 #include <Qt3DRenderer/private/renderer_p.h>
 #include <Qt3DRenderer/private/handle_types_p.h>
 #include <Qt3DCore/qbackendnode.h>
-#include <Qt3DCore/qnodeuuid.h>
+#include <Qt3DCore/qnodeid.h>
 #include <Qt3DCore/qhandle.h>
 #include <QVector>
 
@@ -111,17 +111,17 @@ public:
     }
 
     template<class Backend>
-    QNodeUuid componentUuid() const
+    QNodeId componentUuid() const
     {
-        return QNodeUuid();
+        return QNodeId();
     }
 
     template<class Backend>
-    QList<QNodeUuid> componentUuidInTree() const
+    QList<QNodeId> componentUuidInTree() const
     {
-        QList<QNodeUuid> componentList;
+        QList<QNodeId> componentList;
 
-        QNodeUuid componentId = componentUuid<Backend>();
+        QNodeId componentId = componentUuid<Backend>();
         if (!componentId.isNull())
             componentList.append(componentId);
 
@@ -184,12 +184,12 @@ private:
     Sphere *m_worldBoundingVolume;
 
     // Handles to Components
-    QNodeUuid m_transformComponent;
-    QNodeUuid m_meshComponent;
-    QNodeUuid m_materialComponent;
-    QNodeUuid m_layerComponent;
-    QNodeUuid m_lightComponent;
-    QNodeUuid m_cameraComponent;
+    QNodeId m_transformComponent;
+    QNodeId m_meshComponent;
+    QNodeId m_materialComponent;
+    QNodeId m_layerComponent;
+    QNodeId m_lightComponent;
+    QNodeId m_cameraComponent;
 
     QString m_objectName;
 };
@@ -231,22 +231,22 @@ template<>
 RenderTransform *RenderEntity::renderComponent<RenderTransform>() const;
 
 template<>
-QNodeUuid RenderEntity::componentUuid<RenderTransform>() const;
+QNodeId RenderEntity::componentUuid<RenderTransform>() const;
 
 template<>
-QNodeUuid RenderEntity::componentUuid<RenderCameraLens>() const;
+QNodeId RenderEntity::componentUuid<RenderCameraLens>() const;
 
 template<>
-QNodeUuid RenderEntity::componentUuid<RenderLayer>() const;
+QNodeId RenderEntity::componentUuid<RenderLayer>() const;
 
 template<>
-QNodeUuid RenderEntity::componentUuid<RenderMaterial>() const;
+QNodeId RenderEntity::componentUuid<RenderMaterial>() const;
 
 template<>
-QNodeUuid RenderEntity::componentUuid<RenderLight>() const;
+QNodeId RenderEntity::componentUuid<RenderLight>() const;
 
 template<>
-QNodeUuid RenderEntity::componentUuid<RenderMesh>() const;
+QNodeId RenderEntity::componentUuid<RenderMesh>() const;
 
 class RenderEntityFunctor : public QBackendNodeFunctor
 {
diff --git a/src/render/backend/renderer.cpp b/src/render/backend/renderer.cpp
index 165932bca..d367e47e6 100644
--- a/src/render/backend/renderer.cpp
+++ b/src/render/backend/renderer.cpp
@@ -383,7 +383,7 @@ QFrameAllocator *Renderer::currentFrameAllocator(int frameIndex)
     return data->second->at(frameIndex);
 }
 
-void Renderer::setFrameGraphRoot(const QNodeUuid &frameGraphRootUuid)
+void Renderer::setFrameGraphRoot(const QNodeId &frameGraphRootUuid)
 {
     m_frameGraphRootUuid = frameGraphRootUuid;
     qCDebug(Backend) << Q_FUNC_INFO << m_frameGraphRootUuid;
diff --git a/src/render/backend/renderer_p.h b/src/render/backend/renderer_p.h
index d64e1c7fe..65c6d398e 100644
--- a/src/render/backend/renderer_p.h
+++ b/src/render/backend/renderer_p.h
@@ -138,7 +138,7 @@ public:
 
     QThreadStorage<QPair<int, QFrameAllocatorQueue *> *> *tlsAllocators();
 
-    void setFrameGraphRoot(const QNodeUuid &fgRoot);
+    void setFrameGraphRoot(const QNodeId &fgRoot);
     Render::FrameGraphNode *frameGraphRoot() const;
 
     void setSceneGraphRoot(RenderEntity *sgRoot);
@@ -207,7 +207,7 @@ private:
     QRenderAspect *m_rendererAspect;
 
     // Frame graph root
-    QNodeUuid m_frameGraphRootUuid;
+    QNodeId m_frameGraphRootUuid;
 
     RenderEntity *m_renderSceneRoot;
 
diff --git a/src/render/backend/rendermaterial.cpp b/src/render/backend/rendermaterial.cpp
index e703941f5..ba9a4e96d 100644
--- a/src/render/backend/rendermaterial.cpp
+++ b/src/render/backend/rendermaterial.cpp
@@ -95,16 +95,16 @@ void RenderMaterial::sceneChangeEvent(const QSceneChangePtr &e)
         // Check for shader parameter
     case NodeAdded: {
         if (propertyChange->propertyName() == QByteArrayLiteral("parameter"))
-            m_parameterPack.appendParameter(propertyChange->value().value<QNodeUuid>());
+            m_parameterPack.appendParameter(propertyChange->value().value<QNodeId>());
         else if (propertyChange->propertyName() == QByteArrayLiteral("effect"))
-                m_effectUuid = propertyChange->value().value<QNodeUuid>();
+                m_effectUuid = propertyChange->value().value<QNodeId>();
         break;
     }
     case NodeRemoved: {
         if (propertyChange->propertyName() == QByteArrayLiteral("parameter"))
-            m_parameterPack.removeParameter(propertyChange->value().value<QNodeUuid>());
+            m_parameterPack.removeParameter(propertyChange->value().value<QNodeId>());
         else if (propertyChange->propertyName() == QByteArrayLiteral("effect"))
-            m_effectUuid = QNodeUuid();
+            m_effectUuid = QNodeId();
         break;
     }
 
@@ -113,12 +113,12 @@ void RenderMaterial::sceneChangeEvent(const QSceneChangePtr &e)
     }
 }
 
-QList<QNodeUuid> RenderMaterial::parameters() const
+QList<QNodeId> RenderMaterial::parameters() const
 {
     return m_parameterPack.parameters();
 }
 
-QNodeUuid RenderMaterial::effect() const
+QNodeId RenderMaterial::effect() const
 {
     return m_effectUuid;
 }
diff --git a/src/render/backend/rendermaterial_p.h b/src/render/backend/rendermaterial_p.h
index e0bc1f674..4aff64ff9 100644
--- a/src/render/backend/rendermaterial_p.h
+++ b/src/render/backend/rendermaterial_p.h
@@ -74,13 +74,13 @@ public:
     void updateFromPeer(QNode* mat) Q_DECL_OVERRIDE;
     void sceneChangeEvent(const QSceneChangePtr &e) Q_DECL_OVERRIDE;
 
-    QList<QNodeUuid> parameters() const;
-    QNodeUuid effect() const;
+    QList<QNodeId> parameters() const;
+    QNodeId effect() const;
 
 private:
     RenderTextureProvider* m_textureProvider;
     ParameterPack m_parameterPack;
-    QNodeUuid m_effectUuid;
+    QNodeId m_effectUuid;
 };
 
 } // Render
diff --git a/src/render/backend/renderrenderpass.cpp b/src/render/backend/renderrenderpass.cpp
index e485cd8de..561360955 100644
--- a/src/render/backend/renderrenderpass.cpp
+++ b/src/render/backend/renderrenderpass.cpp
@@ -91,10 +91,10 @@ void RenderRenderPass::sceneChangeEvent(const QSceneChangePtr &e)
 
     case NodeAdded: {
         if (propertyChange->propertyName() == QByteArrayLiteral("annotation")) {
-            appendAnnotation(propertyChange->value().value<QNodeUuid>());
+            appendAnnotation(propertyChange->value().value<QNodeId>());
         }
         else if (propertyChange->propertyName() == QByteArrayLiteral("shaderProgram")) {
-            m_shaderUuid = propertyChange->value().value<QNodeUuid>();
+            m_shaderUuid = propertyChange->value().value<QNodeId>();
         }
         else if (propertyChange->propertyName() == QByteArrayLiteral("binding")) {
             appendBinding(propertyChange->value().value<QParameterMapping *>());
@@ -107,16 +107,16 @@ void RenderRenderPass::sceneChangeEvent(const QSceneChangePtr &e)
 
     case NodeRemoved: {
         if (propertyChange->propertyName() == QByteArrayLiteral("annotation")) {
-            removeAnnotation(propertyChange->value().value<QNodeUuid>());
+            removeAnnotation(propertyChange->value().value<QNodeId>());
         }
         else if (propertyChange->propertyName() == QByteArrayLiteral("shaderProgram")) {
-            m_shaderUuid = QNodeUuid();
+            m_shaderUuid = QNodeId();
         }
         else if (propertyChange->propertyName() == QByteArrayLiteral("binding")) {
-            removeBinding(propertyChange->value().value<QNodeUuid>());
+            removeBinding(propertyChange->value().value<QNodeId>());
         }
         else if (propertyChange->propertyName() == QByteArrayLiteral("renderState")) {
-            removeRenderState(propertyChange->value().value<QNodeUuid>());
+            removeRenderState(propertyChange->value().value<QNodeId>());
         }
         break;
     }
@@ -126,7 +126,7 @@ void RenderRenderPass::sceneChangeEvent(const QSceneChangePtr &e)
     }
 }
 
-QNodeUuid RenderRenderPass::shaderProgram() const
+QNodeId RenderRenderPass::shaderProgram() const
 {
     return m_shaderUuid;
 }
@@ -136,7 +136,7 @@ QList<QParameterMapping *> RenderRenderPass::bindings() const
     return m_bindings.values();
 }
 
-QList<QNodeUuid> RenderRenderPass::annotations() const
+QList<QNodeId> RenderRenderPass::annotations() const
 {
     return m_annotationList;
 }
@@ -146,13 +146,13 @@ QList<QRenderState *> RenderRenderPass::renderStates() const
     return m_renderStates.values();
 }
 
-void RenderRenderPass::appendAnnotation(const QNodeUuid &annotationId)
+void RenderRenderPass::appendAnnotation(const QNodeId &annotationId)
 {
     if (!m_annotationList.contains(annotationId))
         m_annotationList.append(annotationId);
 }
 
-void RenderRenderPass::removeAnnotation(const QNodeUuid &annotationId)
+void RenderRenderPass::removeAnnotation(const QNodeId &annotationId)
 {
     m_annotationList.removeOne(annotationId);
 }
@@ -163,7 +163,7 @@ void RenderRenderPass::appendBinding(QParameterMapping *binding)
         m_bindings[binding->uuid()] = binding;
 }
 
-void RenderRenderPass::removeBinding(const QNodeUuid &bindingId)
+void RenderRenderPass::removeBinding(const QNodeId &bindingId)
 {
     m_bindings.remove(bindingId);
 }
@@ -174,7 +174,7 @@ void RenderRenderPass::appendRenderState(QRenderState *renderState)
         m_renderStates[renderState->uuid()] = renderState;
 }
 
-void RenderRenderPass::removeRenderState(const QNodeUuid &renderStateId)
+void RenderRenderPass::removeRenderState(const QNodeId &renderStateId)
 {
     m_renderStates.remove(renderStateId);
 }
diff --git a/src/render/backend/renderrenderpass_p.h b/src/render/backend/renderrenderpass_p.h
index f511d6e71..7c23fc987 100644
--- a/src/render/backend/renderrenderpass_p.h
+++ b/src/render/backend/renderrenderpass_p.h
@@ -46,7 +46,7 @@
 #include <Qt3DRenderer/qt3drenderer_global.h>
 #include <Qt3DCore/private/qabstractaspect_p.h>
 #include <Qt3DCore/qbackendnode.h>
-#include <Qt3DCore/qnodeuuid.h>
+#include <Qt3DCore/qnodeid.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -71,25 +71,25 @@ public:
 
     void updateFromPeer(QNode *peer) Q_DECL_OVERRIDE;
     void sceneChangeEvent(const QSceneChangePtr &e) Q_DECL_OVERRIDE;
-    QNodeUuid shaderProgram() const;
+    QNodeId shaderProgram() const;
     QList<QParameterMapping *> bindings() const;
-    QList<QNodeUuid> annotations() const;
+    QList<QNodeId> annotations() const;
     QList<QRenderState *> renderStates() const;
 
-    void appendAnnotation(const QNodeUuid &criterionId);
-    void removeAnnotation(const QNodeUuid &criterionId);
+    void appendAnnotation(const QNodeId &criterionId);
+    void removeAnnotation(const QNodeId &criterionId);
 
     void appendBinding(QParameterMapping *binding);
-    void removeBinding(const QNodeUuid &bindingId);
+    void removeBinding(const QNodeId &bindingId);
 
     void appendRenderState(QRenderState *renderState);
-    void removeRenderState(const QNodeUuid &renderStateId);
+    void removeRenderState(const QNodeId &renderStateId);
 
 private:
-    QNodeUuid m_shaderUuid;
-    QHash<QNodeUuid, QParameterMapping *> m_bindings;
-    QHash<QNodeUuid, QRenderState *> m_renderStates;
-    QList<QNodeUuid> m_annotationList;
+    QNodeId m_shaderUuid;
+    QHash<QNodeId, QParameterMapping *> m_bindings;
+    QHash<QNodeId, QRenderState *> m_renderStates;
+    QList<QNodeId> m_annotationList;
 };
 
 } // Render
diff --git a/src/render/backend/rendertarget.cpp b/src/render/backend/rendertarget.cpp
index f9d8fa715..d636f0d52 100644
--- a/src/render/backend/rendertarget.cpp
+++ b/src/render/backend/rendertarget.cpp
@@ -68,18 +68,18 @@ void RenderTarget::cleanup()
 {
 }
 
-void RenderTarget::appendRenderAttachment(const QNodeUuid &attachmentId)
+void RenderTarget::appendRenderAttachment(const QNodeId &attachmentId)
 {
     if (!m_renderAttachments.contains(attachmentId))
         m_renderAttachments.append(attachmentId);
 }
 
-void RenderTarget::removeRenderAttachment(const QNodeUuid &attachmentId)
+void RenderTarget::removeRenderAttachment(const QNodeId &attachmentId)
 {
     m_renderAttachments.removeOne(attachmentId);
 }
 
-QList<QNodeUuid> RenderTarget::renderAttachments() const
+QList<QNodeId> RenderTarget::renderAttachments() const
 {
     return m_renderAttachments;
 }
@@ -88,9 +88,9 @@ void RenderTarget::sceneChangeEvent(const QSceneChangePtr &e)
 {
     QScenePropertyChangePtr propertyChange = qSharedPointerCast<QScenePropertyChange>(e);
     if (e->type() == NodeAdded && propertyChange->propertyName() == QByteArrayLiteral("attachment"))
-        appendRenderAttachment(propertyChange->value().value<QNodeUuid>());
+        appendRenderAttachment(propertyChange->value().value<QNodeId>());
     else if (e->type() == NodeRemoved && propertyChange->propertyName() == QByteArrayLiteral("attachment"))
-        removeRenderAttachment(propertyChange->value().value<QNodeUuid>());
+        removeRenderAttachment(propertyChange->value().value<QNodeId>());
 }
 
 } // Render
diff --git a/src/render/backend/rendertarget_p.h b/src/render/backend/rendertarget_p.h
index d9748d0cb..8b7b09851 100644
--- a/src/render/backend/rendertarget_p.h
+++ b/src/render/backend/rendertarget_p.h
@@ -43,7 +43,7 @@
 #define QT3D_RENDER_RENDERTARGET_H
 
 #include <Qt3DCore/qbackendnode.h>
-#include <Qt3DCore/qnodeuuid.h>
+#include <Qt3DCore/qnodeid.h>
 #include <QList>
 
 QT_BEGIN_NAMESPACE
@@ -65,15 +65,15 @@ public:
     void updateFromPeer(QNode *peer) Q_DECL_OVERRIDE;
     void cleanup();
 
-    void appendRenderAttachment(const QNodeUuid &attachmentId);
-    void removeRenderAttachment(const QNodeUuid &attachmentId);
+    void appendRenderAttachment(const QNodeId &attachmentId);
+    void removeRenderAttachment(const QNodeId &attachmentId);
 
-    QList<QNodeUuid> renderAttachments() const;
+    QList<QNodeId> renderAttachments() const;
 
     void sceneChangeEvent(const QSceneChangePtr &e) Q_DECL_OVERRIDE;
 
 private:
-    QList<QNodeUuid> m_renderAttachments;
+    QList<QNodeId> m_renderAttachments;
 };
 
 } // Render
diff --git a/src/render/backend/rendertechnique.cpp b/src/render/backend/rendertechnique.cpp
index aba618810..d5c2baa32 100644
--- a/src/render/backend/rendertechnique.cpp
+++ b/src/render/backend/rendertechnique.cpp
@@ -115,26 +115,26 @@ void RenderTechnique::sceneChangeEvent(const QSceneChangePtr &e)
 
     case NodeAdded: {
         if (propertyChange->propertyName() == QByteArrayLiteral("pass")) {
-            appendRenderPass(propertyChange->value().value<QNodeUuid>());
+            appendRenderPass(propertyChange->value().value<QNodeId>());
         }
         else if (propertyChange->propertyName() == QByteArrayLiteral("parameter")) {
-            m_parameterPack.appendParameter(propertyChange->value().value<QNodeUuid>());
+            m_parameterPack.appendParameter(propertyChange->value().value<QNodeId>());
         }
         else if (propertyChange->propertyName() == QByteArrayLiteral("annotation")) {
-            appendAnnotation(propertyChange->value().value<QNodeUuid>());
+            appendAnnotation(propertyChange->value().value<QNodeId>());
         }
         break;
     }
 
     case NodeRemoved: {
         if (propertyChange->propertyName() == QByteArrayLiteral("pass")) {
-            removeRenderPass(propertyChange->value().value<QNodeUuid>());
+            removeRenderPass(propertyChange->value().value<QNodeId>());
         }
         else if (propertyChange->propertyName() == QByteArrayLiteral("parameter")) {
-            m_parameterPack.removeParameter(propertyChange->value().value<QNodeUuid>());
+            m_parameterPack.removeParameter(propertyChange->value().value<QNodeId>());
         }
         else if (propertyChange->propertyName() == QByteArrayLiteral("annotation")) {
-            removeAnnotation(propertyChange->value().value<QNodeUuid>());
+            removeAnnotation(propertyChange->value().value<QNodeId>());
         }
         break;
     }
@@ -144,28 +144,28 @@ void RenderTechnique::sceneChangeEvent(const QSceneChangePtr &e)
     }
 }
 
-QList<QNodeUuid> RenderTechnique::parameters() const
+QList<QNodeId> RenderTechnique::parameters() const
 {
     return m_parameterPack.parameters();
 }
 
-void RenderTechnique::appendRenderPass(const QNodeUuid &renderPassId)
+void RenderTechnique::appendRenderPass(const QNodeId &renderPassId)
 {
     if (!m_renderPasses.contains(renderPassId))
         m_renderPasses.append(renderPassId);
 }
 
-void RenderTechnique::removeRenderPass(const QNodeUuid &renderPassId)
+void RenderTechnique::removeRenderPass(const QNodeId &renderPassId)
 {
     m_renderPasses.removeOne(renderPassId);
 }
 
-QList<QNodeUuid> RenderTechnique::annotations() const
+QList<QNodeId> RenderTechnique::annotations() const
 {
     return m_annotationList;
 }
 
-QList<QNodeUuid> RenderTechnique::renderPasses() const
+QList<QNodeId> RenderTechnique::renderPasses() const
 {
     return m_renderPasses;
 }
@@ -175,13 +175,13 @@ QOpenGLFilter *RenderTechnique::openGLFilter() const
     return m_openglFilter;
 }
 
-void RenderTechnique::appendAnnotation(const QNodeUuid &criterionId)
+void RenderTechnique::appendAnnotation(const QNodeId &criterionId)
 {
     if (!m_annotationList.contains(criterionId))
         m_annotationList.append(criterionId);
 }
 
-void RenderTechnique::removeAnnotation(const QNodeUuid &criterionId)
+void RenderTechnique::removeAnnotation(const QNodeId &criterionId)
 {
     m_annotationList.removeOne(criterionId);
 }
diff --git a/src/render/backend/rendertechnique_p.h b/src/render/backend/rendertechnique_p.h
index af89832ce..bc379c769 100644
--- a/src/render/backend/rendertechnique_p.h
+++ b/src/render/backend/rendertechnique_p.h
@@ -73,24 +73,24 @@ public:
     void updateFromPeer(QNode *peer) Q_DECL_OVERRIDE;
 
     void sceneChangeEvent(const QSceneChangePtr &e);
-    QList<QNodeUuid> parameters() const;
+    QList<QNodeId> parameters() const;
 
-    void appendRenderPass(const QNodeUuid &renderPassId);
-    void removeRenderPass(const QNodeUuid &renderPassId);
+    void appendRenderPass(const QNodeId &renderPassId);
+    void removeRenderPass(const QNodeId &renderPassId);
 
-    void appendAnnotation(const QNodeUuid &criterionId);
-    void removeAnnotation(const QNodeUuid &criterionId);
+    void appendAnnotation(const QNodeId &criterionId);
+    void removeAnnotation(const QNodeId &criterionId);
 
-    QList<QNodeUuid> annotations() const;
-    QList<QNodeUuid> renderPasses() const;
+    QList<QNodeId> annotations() const;
+    QList<QNodeId> renderPasses() const;
     QOpenGLFilter *openGLFilter() const;
 
 private:
     QOpenGLFilter *m_openglFilter;
 
     ParameterPack m_parameterPack;
-    QList<QNodeUuid> m_annotationList;
-    QList<QNodeUuid> m_renderPasses;
+    QList<QNodeId> m_annotationList;
+    QList<QNodeId> m_renderPasses;
 };
 
 } // namespace Render
diff --git a/src/render/backend/renderview_p.h b/src/render/backend/renderview_p.h
index 925a2f7c0..1e66aead7 100644
--- a/src/render/backend/renderview_p.h
+++ b/src/render/backend/renderview_p.h
@@ -188,7 +188,7 @@ public:
     void setRenderTargetHandle(HTarget renderTargetHandle) { m_renderTarget = renderTargetHandle; }
     HTarget renderTargetHandle() const { return m_renderTarget; }
 
-    void addSortCriteria(const QList<QNodeUuid> &sortMethodUid) { m_data->m_sortingCriteria.append(sortMethodUid); }
+    void addSortCriteria(const QList<QNodeId> &sortMethodUid) { m_data->m_sortingCriteria.append(sortMethodUid); }
 
 private:
     void setShaderAndUniforms(RenderCommand *command, RenderRenderPass *pass, QHash<QString, QVariant> &parameters, const QMatrix4x4 &worldTransform);
@@ -213,7 +213,7 @@ private:
         QMatrix4x4 *m_viewMatrix;
         QStringList m_layers;
         QList<LightPair> m_lights;
-        QList<QNodeUuid> m_sortingCriteria;
+        QList<QNodeId> m_sortingCriteria;
         QVector3D m_eyePos;
     } *m_data;
 
diff --git a/src/render/backend/scenemanager.cpp b/src/render/backend/scenemanager.cpp
index 0d5b358b9..3ca688112 100644
--- a/src/render/backend/scenemanager.cpp
+++ b/src/render/backend/scenemanager.cpp
@@ -48,14 +48,14 @@ namespace Qt3D {
 namespace Render {
 
 SceneManager::SceneManager() : QResourceManager<RenderScene,
-                                                 QNodeUuid,
+                                                 QNodeId,
                                                  8,
                                                  Qt3D::ArrayAllocatingPolicy,
                                                  Qt3D::ObjectLevelLockingPolicy>()
 {
 }
 
-void SceneManager::addSceneData(const QString &source, const QNodeUuid &sceneUuid)
+void SceneManager::addSceneData(const QString &source, const QNodeId &sceneUuid)
 {
     m_pendingJobs.append(LoadSceneJobPtr(new LoadSceneJob(source, sceneUuid)));
 }
diff --git a/src/render/backend/scenemanager_p.h b/src/render/backend/scenemanager_p.h
index 203aa1c55..0e867ce9e 100644
--- a/src/render/backend/scenemanager_p.h
+++ b/src/render/backend/scenemanager_p.h
@@ -45,7 +45,7 @@
 #include <Qt3DCore/private/qresourcemanager_p.h>
 #include <Qt3DRenderer/private/renderscene_p.h>
 #include <Qt3DRenderer/loadscenejob.h>
-#include <Qt3DCore/qnodeuuid.h>
+#include <Qt3DCore/qnodeid.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -56,7 +56,7 @@ class QEntity;
 namespace Render {
 
 class SceneManager : public QResourceManager<RenderScene,
-                                             QNodeUuid,
+                                             QNodeId,
                                              8,
                                              Qt3D::ArrayAllocatingPolicy,
                                              Qt3D::ObjectLevelLockingPolicy>
@@ -64,7 +64,7 @@ class SceneManager : public QResourceManager<RenderScene,
 public:
     SceneManager();
 
-    void addSceneData(const QString &source, const QNodeUuid &sceneUuid);
+    void addSceneData(const QString &source, const QNodeId &sceneUuid);
     QVector<LoadSceneJobPtr> pendingSceneLoaderJobs();
 
     void addLoadedSceneTree(const QString &source, QEntity *tree);
diff --git a/src/render/backend/texturedatamanager_p.h b/src/render/backend/texturedatamanager_p.h
index dbfc102b7..08b8fc38e 100644
--- a/src/render/backend/texturedatamanager_p.h
+++ b/src/render/backend/texturedatamanager_p.h
@@ -47,7 +47,7 @@
 #include <Qt3DRenderer/texturedata.h>
 #include <Qt3DRenderer/private/handle_types_p.h>
 
-#include <Qt3DCore/qnodeuuid.h>
+#include <Qt3DCore/qnodeid.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -56,7 +56,7 @@ namespace Qt3D {
 namespace Render {
 
 class TextureDataManager : public QResourceManager<TexImageData,
-                                                   QNodeUuid,
+                                                   QNodeId,
                                                    16,
                                                    Qt3D::ListAllocatingPolicy,
                                                    Qt3D::ObjectLevelLockingPolicy>
diff --git a/src/render/frontend/qabstractmesh_p.h b/src/render/frontend/qabstractmesh_p.h
index 0ba5df177..5c4bbf09f 100644
--- a/src/render/frontend/qabstractmesh_p.h
+++ b/src/render/frontend/qabstractmesh_p.h
@@ -46,7 +46,7 @@
 #include <private/qcomponent_p.h>
 
 #include <QString>
-#include <Qt3DCore/qnodeuuid.h>
+#include <Qt3DCore/qnodeid.h>
 #include <QSharedPointer>
 
 QT_BEGIN_NAMESPACE
@@ -62,7 +62,7 @@ public:
 
     Q_DECLARE_PUBLIC(QAbstractMesh)
 
-    QNodeUuid m_uuid;
+    QNodeId m_uuid;
 };
 
 }
diff --git a/src/render/frontend/qsceneloader.cpp b/src/render/frontend/qsceneloader.cpp
index 35443f77d..c378a1517 100644
--- a/src/render/frontend/qsceneloader.cpp
+++ b/src/render/frontend/qsceneloader.cpp
@@ -66,10 +66,10 @@ void QSceneLoader::sceneChangeEvent(const QSceneChangePtr &change)
             QEntity *scene = e->value().value<QEntity *>();
             // TO DO: We should send a QNodePtr so that it is release automatically
             if (scene != Q_NULLPTR && d->m_scene != Q_NULLPTR) {
-                QList<QNodeUuid> entities = d->m_scene->entitiesForComponent(d->m_uuid);
+                QList<QNodeId> entities = d->m_scene->entitiesForComponent(d->m_uuid);
                 if (entities.size() > 1) // TO DO: QComponent shareable property
                     qCWarning(Render::Frontend) << "It is strongly discouraged to share SceneLoader component between entities";
-                Q_FOREACH (const QNodeUuid &id, entities) {
+                Q_FOREACH (const QNodeId &id, entities) {
                     QEntity *parentEntity = qobject_cast<QEntity *>(d->m_scene->lookupNode(id));
                     if (parentEntity != Q_NULLPTR) {
                         QEntity *cloneScene = qobject_cast<QEntity *>(QNodePrivate::get(scene)->clone());
diff --git a/tests/auto/core/qscene/tst_qscene.cpp b/tests/auto/core/qscene/tst_qscene.cpp
index 7197f5286..1445645af 100644
--- a/tests/auto/core/qscene/tst_qscene.cpp
+++ b/tests/auto/core/qscene/tst_qscene.cpp
@@ -192,7 +192,7 @@ void tst_QScene::removeObservable()
     scene->removeObservable(observables.at(0), node2->uuid());
     QCOMPARE(scene->lookupObservables(node2->uuid()).count(), 5);
 
-    QVERIFY(scene->nodeIdFromObservable(observables.at(0)) == Qt3D::QNodeUuid());
+    QVERIFY(scene->nodeIdFromObservable(observables.at(0)) == Qt3D::QNodeId());
 }
 
 void tst_QScene::removeNodeObservable()
@@ -227,7 +227,7 @@ void tst_QScene::removeNodeObservable()
 
     QVERIFY(scene->lookupNode(node1->uuid()) == Q_NULLPTR);
     QVERIFY(scene->lookupObservables(node1->uuid()).empty());
-    QVERIFY(scene->nodeIdFromObservable(observables.at(0)) == Qt3D::QNodeUuid());
+    QVERIFY(scene->nodeIdFromObservable(observables.at(0)) == Qt3D::QNodeId());
 
     QVERIFY(scene->lookupNode(node2->uuid()) == node2);
     QCOMPARE(scene->lookupObservables(node2->uuid()).count(), 5);
@@ -314,7 +314,7 @@ void tst_QScene::addEntityForComponent()
     }
 
     for (int i = 0; i < 10; i++) {
-        QList<Qt3D::QNodeUuid> uuids = scene->entitiesForComponent(components.at(i)->uuid());
+        QList<Qt3D::QNodeId> uuids = scene->entitiesForComponent(components.at(i)->uuid());
         QCOMPARE(uuids.count(), 10);
     }
 }