Rename QNodeUuid to QNodeId

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

45 files changed, 220 insertions, 220 deletions

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>