Rename RenderTexture -> Texture

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

14 files changed, 70 insertions, 70 deletions

diff --git a/src/render/backend/handle_types_p.h b/src/render/backend/handle_types_p.h
index da44b6813..d8ea6468f 100644
--- a/src/render/backend/handle_types_p.h
+++ b/src/render/backend/handle_types_p.h
@@ -62,7 +62,7 @@ class Layer;
 class Material;
 class SortCriterion;
 class Technique;
-class RenderTexture;
+class Texture;
 class RenderTransform;
 class RenderTarget;
 class RenderPass;
@@ -88,7 +88,7 @@ typedef Qt3D::QHandle<QOpenGLVertexArrayObject*, 16> HVao;
 typedef Qt3D::QHandle<Shader, 16> HShader;
 typedef Qt3D::QHandle<SortCriterion, 8> HSortCriterion;
 typedef Qt3D::QHandle<Technique, 16> HTechnique;
-typedef Qt3D::QHandle<RenderTexture, 16> HTexture;
+typedef Qt3D::QHandle<Texture, 16> HTexture;
 typedef Qt3D::QHandle<RenderTransform, 16> HTransform;
 typedef Qt3D::QHandle<RenderTarget, 8> HTarget;
 typedef Qt3D::QHandle<RenderPass, 16> HRenderPass;
diff --git a/src/render/backend/jobs/loadtexturedatajob.cpp b/src/render/backend/jobs/loadtexturedatajob.cpp
index ceb83cf53..1a0ceeb8e 100644
--- a/src/render/backend/jobs/loadtexturedatajob.cpp
+++ b/src/render/backend/jobs/loadtexturedatajob.cpp
@@ -58,7 +58,7 @@ void LoadTextureDataJob::run()
 {
     qCDebug(Jobs) << "Entering" << Q_FUNC_INFO << QThread::currentThread();
 
-    RenderTexture *txt = m_renderer->textureManager()->lookupResource(m_textureId);
+    Texture *txt = m_renderer->textureManager()->lookupResource(m_textureId);
 
     if (txt != Q_NULLPTR) {
         // Load update each TextureImage
diff --git a/src/render/backend/managers_p.h b/src/render/backend/managers_p.h
index ca54974f1..a9eea7217 100644
--- a/src/render/backend/managers_p.h
+++ b/src/render/backend/managers_p.h
@@ -48,7 +48,7 @@
 #include <Qt3DRenderer/private/shader_p.h>
 #include <Qt3DRenderer/private/sortcriterion_p.h>
 #include <Qt3DRenderer/private/technique_p.h>
-#include <Qt3DRenderer/private/rendertexture_p.h>
+#include <Qt3DRenderer/private/texture_p.h>
 #include <Qt3DRenderer/private/rendertransform_p.h>
 #include <Qt3DRenderer/private/rendertarget_p.h>
 #include <Qt3DRenderer/private/renderpass_p.h>
@@ -188,7 +188,7 @@ public:
 };
 
 class TextureManager : public Qt3D::QResourceManager<
-        RenderTexture,
+        Texture,
         Qt3D::QNodeId,
         16,
         Qt3D::ArrayAllocatingPolicy,
@@ -311,7 +311,7 @@ Q_DECLARE_RESOURCE_INFO(Qt3DRender::Render::Shader, Q_REQUIRES_CLEANUP)
 Q_DECLARE_RESOURCE_INFO(Qt3DRender::Render::SortCriterion, Q_REQUIRES_CLEANUP)
 Q_DECLARE_RESOURCE_INFO(Qt3DRender::Render::RenderTarget, Q_REQUIRES_CLEANUP)
 Q_DECLARE_RESOURCE_INFO(Qt3DRender::Render::Technique, Q_REQUIRES_CLEANUP)
-Q_DECLARE_RESOURCE_INFO(Qt3DRender::Render::RenderTexture, Q_REQUIRES_CLEANUP)
+Q_DECLARE_RESOURCE_INFO(Qt3DRender::Render::Texture, Q_REQUIRES_CLEANUP)
 Q_DECLARE_RESOURCE_INFO(Qt3DRender::Render::RenderPass, Q_REQUIRES_CLEANUP)
 Q_DECLARE_RESOURCE_INFO(Qt3DRender::Render::RenderTextureImage, Q_REQUIRES_CLEANUP)
 Q_DECLARE_RESOURCE_INFO(Qt3DRender::Render::Attribute, Q_REQUIRES_CLEANUP)
diff --git a/src/render/backend/parameter.cpp b/src/render/backend/parameter.cpp
index 08cc98a24..afc44ed58 100644
--- a/src/render/backend/parameter.cpp
+++ b/src/render/backend/parameter.cpp
@@ -102,7 +102,7 @@ QVariant Parameter::toBackendValue(const QVariant &value)
     if (node == Q_NULLPTR) {
         return value;
     } else if (qobject_cast<QAbstractTextureProvider*>(node)) {
-        return QVariant::fromValue(static_cast<RenderTexture*>(createBackendNode(node)));
+        return QVariant::fromValue(static_cast<Texture*>(createBackendNode(node)));
     } else if (qobject_cast<QShaderData*>(node)) {
         return QVariant::fromValue(static_cast<ShaderData*>(createBackendNode(node)));
     } else {
diff --git a/src/render/backend/qgraphicscontext.cpp b/src/render/backend/qgraphicscontext.cpp
index 7d64720b5..ee6f0fed8 100644
--- a/src/render/backend/qgraphicscontext.cpp
+++ b/src/render/backend/qgraphicscontext.cpp
@@ -42,7 +42,7 @@
 #include <Qt3DRenderer/private/renderlogging_p.h>
 #include <Qt3DRenderer/private/shader_p.h>
 #include <Qt3DRenderer/private/material_p.h>
-#include <Qt3DRenderer/private/rendertexture_p.h>
+#include <Qt3DRenderer/private/texture_p.h>
 #include <Qt3DRenderer/private/buffer_p.h>
 #include <Qt3DRenderer/private/attribute_p.h>
 #include <Qt3DRenderer/private/rendercommand_p.h>
@@ -402,7 +402,7 @@ void QGraphicsContext::activateRenderTarget(RenderTarget *renderTarget, const At
             // We need to check if  one of the attachment was resized
             bool needsResize = false;
             Q_FOREACH (const Attachment &attachment, attachments.attachments()) {
-                RenderTexture *rTex = m_renderer->textureManager()->lookupResource(attachment.m_textureUuid);
+                Texture *rTex = m_renderer->textureManager()->lookupResource(attachment.m_textureUuid);
                 if (rTex != Q_NULLPTR)
                     needsResize |= rTex->isTextureReset();
             }
@@ -424,7 +424,7 @@ void QGraphicsContext::bindFrameBufferAttachmentHelper(GLuint fboId, const Attac
 
     QSize fboSize;
     Q_FOREACH (const Attachment &attachment, attachments.attachments()) {
-        RenderTexture *rTex = m_renderer->textureManager()->lookupResource(attachment.m_textureUuid);
+        Texture *rTex = m_renderer->textureManager()->lookupResource(attachment.m_textureUuid);
         if (rTex != Q_NULLPTR) {
             QOpenGLTexture *glTex = rTex->getOrCreateGLTexture();
             if (glTex != Q_NULLPTR) {
@@ -484,7 +484,7 @@ void QGraphicsContext::executeCommand(const RenderCommand *)
 {
 }
 
-int QGraphicsContext::activateTexture(TextureScope scope, RenderTexture *tex, int onUnit)
+int QGraphicsContext::activateTexture(TextureScope scope, Texture *tex, int onUnit)
 {
     // Returns the texture unit to use for the texture
     // This always return a valid unit, unless there are more textures than
@@ -574,7 +574,7 @@ void QGraphicsContext::resolveHighestOpenGLFunctions()
     m_contextInfo->setVendor(QString::fromUtf8(reinterpret_cast<const char *>(m_gl->functions()->glGetString(GL_VENDOR))));
 }
 
-void QGraphicsContext::deactivateTexture(RenderTexture* tex)
+void QGraphicsContext::deactivateTexture(Texture* tex)
 {
     for (int u=0; u<m_activeTextures.size(); ++u) {
         if (m_activeTextures[u] == tex->dna()) {
@@ -785,7 +785,7 @@ void QGraphicsContext::disablePrimitiveRestart()
     Tries to use the texture unit with the texture that hasn't been used for the longest time
     if the texture happens not to be already pinned on a texture unit.
  */
-GLint QGraphicsContext::assignUnitForTexture(RenderTexture *tex)
+GLint QGraphicsContext::assignUnitForTexture(Texture *tex)
 {
     int lowestScoredUnit = -1;
     int lowestScore = 0xfffffff;
@@ -853,7 +853,7 @@ void QGraphicsContext::setUniforms(QUniformPack &uniforms)
     const QHash<QString, const QUniformValue *> &uniformValues = uniforms.uniforms();
     for (int i = 0; i < uniforms.textures().size(); ++i) {
         const QUniformPack::NamedTexture &namedTex = uniforms.textures().at(i);
-        RenderTexture *t = m_renderer->textureManager()->lookupResource(namedTex.texId);
+        Texture *t = m_renderer->textureManager()->lookupResource(namedTex.texId);
         const TextureUniform *texUniform = Q_NULLPTR;
         // TO DO : Rework the way textures are loaded
         if (t != Q_NULLPTR) {
diff --git a/src/render/backend/qgraphicscontext_p.h b/src/render/backend/qgraphicscontext_p.h
index b21e33543..679f592ea 100644
--- a/src/render/backend/qgraphicscontext_p.h
+++ b/src/render/backend/qgraphicscontext_p.h
@@ -66,7 +66,7 @@ class Renderer;
 class QGraphicsHelperInterface;
 class RenderStateSet;
 class Material;
-class RenderTexture;
+class Texture;
 class RenderCommand;
 class RenderTarget;
 class AttachmentPack;
@@ -149,9 +149,9 @@ public:
      * @param onUnit - option, specify the explicit unit to activate on
      * @return - the unit the texture was activated on
      */
-    int activateTexture(TextureScope scope, RenderTexture* tex, int onUnit = -1);
+    int activateTexture(TextureScope scope, Texture* tex, int onUnit = -1);
 
-    void deactivateTexture(RenderTexture *tex);
+    void deactivateTexture(Texture *tex);
 
     void setCurrentStateSet(RenderStateSet* ss);
     RenderStateSet *currentStateSet() const;
@@ -198,7 +198,7 @@ private:
 
     void decayTextureScores();
 
-    GLint assignUnitForTexture(RenderTexture* tex);
+    GLint assignUnitForTexture(Texture* tex);
     void deactivateTexturesWithScope(TextureScope ts);
 
     void resolveHighestOpenGLFunctions();
diff --git a/src/render/backend/qrenderaspect.cpp b/src/render/backend/qrenderaspect.cpp
index ad8253e97..9a9d9a462 100644
--- a/src/render/backend/qrenderaspect.cpp
+++ b/src/render/backend/qrenderaspect.cpp
@@ -205,7 +205,7 @@ void QRenderAspect::registerBackendTypes()
     registerBackendType<Qt3D::QTransform>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::RenderTransform, Render::TransformManager>(d->m_renderer->transformManager())));
     registerBackendType<QMaterial>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Material, Render::MaterialManager>(d->m_renderer->materialManager())));
     registerBackendType<QTechnique>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Technique, Render::TechniqueManager>(d->m_renderer->techniqueManager())));
-    registerBackendType<QAbstractTextureProvider>(QBackendNodeFunctorPtr(new Render::RenderTextureFunctor(d->m_renderer->textureManager(), d->m_renderer->textureImageManager(), d->m_renderer->textureDataManager())));
+    registerBackendType<QAbstractTextureProvider>(QBackendNodeFunctorPtr(new Render::TextureFunctor(d->m_renderer->textureManager(), d->m_renderer->textureImageManager(), d->m_renderer->textureDataManager())));
     registerBackendType<QShaderProgram>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Shader, Render::ShaderManager>(d->m_renderer->shaderManager())));
     registerBackendType<QEffect>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Effect, Render::EffectManager>(d->m_renderer->effectManager())));
     registerBackendType<QAnnotation>(QBackendNodeFunctorPtr(new Render::NodeFunctor<Render::Annotation, Render::CriterionManager>(d->m_renderer->criterionManager())));
diff --git a/src/render/backend/quniformvalue.cpp b/src/render/backend/quniformvalue.cpp
index 20ada25e4..e18e892c1 100644
--- a/src/render/backend/quniformvalue.cpp
+++ b/src/render/backend/quniformvalue.cpp
@@ -37,7 +37,7 @@
 #include "quniformvalue_p.h"
 
 #include <Qt3DRenderer/private/qgraphicscontext_p.h>
-#include <Qt3DRenderer/private/rendertexture_p.h>
+#include <Qt3DRenderer/private/texture_p.h>
 
 #include <Qt3DCore/qframeallocator.h>
 
diff --git a/src/render/backend/render-backend.pri b/src/render/backend/render-backend.pri
index b496b6320..a39a06eb9 100644
--- a/src/render/backend/render-backend.pri
+++ b/src/render/backend/render-backend.pri
@@ -11,7 +11,6 @@ HEADERS += \
     $$PWD/renderer_p.h \
     $$PWD/qgraphicscontext_p.h \
     $$PWD/quniformvalue_p.h \
-    $$PWD/rendertexture_p.h \
     $$PWD/states/blendstate_p.h \
     $$PWD/genericstate_p.h \
     $$PWD/qgraphicshelperinterface_p.h \
@@ -61,7 +60,8 @@ HEADERS += \
     $$PWD/scene_p.h \
     $$PWD/shaderdata_p.h \
     $$PWD/shader_p.h \
-    $$PWD/technique_p.h
+    $$PWD/technique_p.h \
+    $$PWD/texture_p.h
 
 SOURCES += \
     $$PWD/qrenderaspect.cpp \
@@ -70,7 +70,6 @@ SOURCES += \
     $$PWD/renderer.cpp \
     $$PWD/qgraphicscontext.cpp \
     $$PWD/quniformvalue.cpp \
-    $$PWD/rendertexture.cpp \
     $$PWD/states/blendstate.cpp \
     $$PWD/qgraphicshelpergl4.cpp \
     $$PWD/qgraphicshelpergl3.cpp \
@@ -110,4 +109,5 @@ SOURCES += \
     $$PWD/scene.cpp \
     $$PWD/shaderdata.cpp \
     $$PWD/shader.cpp \
-    $$PWD/technique.cpp
+    $$PWD/technique.cpp \
+    $$PWD/texture.cpp
diff --git a/src/render/backend/rendercommand_p.h b/src/render/backend/rendercommand_p.h
index e123d9be9..eab9447e9 100644
--- a/src/render/backend/rendercommand_p.h
+++ b/src/render/backend/rendercommand_p.h
@@ -63,7 +63,7 @@ public:
     HVao m_vao; // VAO used during the submission step to store all states and VBOs
     HShader m_shader; // Shader for given pass and mesh
     QUniformPack m_uniforms; // Might need to be reworked so as to be able to destroy the
-                            // RenderTexture while submission is happening.
+                            // Texture while submission is happening.
     GLint m_instancesCount; // Number of instances of the mesh, if 0 regular draw otherwise glDrawArraysInstanced or glDrawElementsInstanced
     RenderStateSet *m_stateSet;
 
diff --git a/src/render/backend/rendertextureimage.cpp b/src/render/backend/rendertextureimage.cpp
index c54bd2eec..87146681f 100644
--- a/src/render/backend/rendertextureimage.cpp
+++ b/src/render/backend/rendertextureimage.cpp
@@ -80,14 +80,14 @@ void RenderTextureImage::updateFromPeer(Qt3D::QNode *peer)
     m_mipmapLevel = textureImage->mipmapLevel();
     m_face = textureImage->cubeMapFace();
     m_functor = textureImage->dataFunctor();
-    // Notify the RenderTexture that we are one of its TextureImage
+    // Notify the Texture that we are one of its TextureImage
     if (!peer->parentNode()) {
         qWarning() << "Not QAbstractTextureProvider parent found";
     } else {
         m_textureProviderId = peer->parentNode()->id();
         m_textureProvider = m_textureManager->lookupHandle(m_textureProviderId);
-        RenderTexture *txt = m_textureManager->data(m_textureProvider);
-        // Notify the RenderTexture that it has a new RenderTextureImage and needs an update
+        Texture *txt = m_textureManager->data(m_textureProvider);
+        // Notify the Texture that it has a new RenderTextureImage and needs an update
         txt->addTextureImageData(m_textureImageManager->lookupHandle(peerUuid()));
         if (txt != Q_NULLPTR)
             txt->addToPendingTextureJobs();
@@ -113,8 +113,8 @@ void RenderTextureImage::sceneChangeEvent(const Qt3D::QSceneChangePtr &e)
             m_dirty = true;
         }
     }
-    if (m_dirty) {// Notify the RenderTexture that we were updated and request it to schedule an update job
-        RenderTexture *txt = m_textureManager->data(m_textureProvider);
+    if (m_dirty) {// Notify the Texture that we were updated and request it to schedule an update job
+        Texture *txt = m_textureManager->data(m_textureProvider);
         if (txt != Q_NULLPTR)
             txt->addToPendingTextureJobs();
     }
diff --git a/src/render/backend/renderview.cpp b/src/render/backend/renderview.cpp
index 19688ffd3..7a1eacf76 100644
--- a/src/render/backend/renderview.cpp
+++ b/src/render/backend/renderview.cpp
@@ -468,9 +468,9 @@ void RenderView::setUniformValue(QUniformPack &uniformPack, const QString &name,
     if (const QUniformValue *val = uniformPack.uniform(name))
         destroyUniformValue(val, m_allocator);
 
-    RenderTexture *tex = Q_NULLPTR;
+    Texture *tex = Q_NULLPTR;
 
-    if ((tex = value.value<RenderTexture *>()) != Q_NULLPTR) {
+    if ((tex = value.value<Texture *>()) != Q_NULLPTR) {
         uniformPack.setTexture(name, tex->peerUuid());
         TextureUniform *texUniform = m_allocator->allocate<TextureUniform>();
         texUniform->setTextureId(tex->peerUuid());
diff --git a/src/render/backend/rendertexture.cpp b/src/render/backend/texture.cpp
index 2c411d19a..12f2c3b9a 100644
--- a/src/render/backend/rendertexture.cpp
+++ b/src/render/backend/texture.cpp
@@ -35,7 +35,7 @@
 ****************************************************************************/
 
 #include <QtCore/qhash.h>
-#include "rendertexture_p.h"
+#include "texture_p.h"
 
 #include <QDebug>
 #include <QOpenGLFunctions>
@@ -55,7 +55,7 @@ using namespace Qt3D;
 namespace Qt3DRender {
 namespace Render {
 
-RenderTexture::RenderTexture()
+Texture::Texture()
     : QBackendNode()
     , m_gl(Q_NULLPTR)
     , m_width(1)
@@ -86,14 +86,14 @@ RenderTexture::RenderTexture()
     // We need backend -> frontend notifications to update the status of the texture
 }
 
-RenderTexture::~RenderTexture()
+Texture::~Texture()
 {
     if (m_lock != Q_NULLPTR)
         delete m_lock;
     m_lock = Q_NULLPTR;
 }
 
-void RenderTexture::cleanup()
+void Texture::cleanup()
 {
     m_gl = Q_NULLPTR;
     m_width = 1;
@@ -123,7 +123,7 @@ void RenderTexture::cleanup()
 }
 
 // AspectThread
-void RenderTexture::updateFromPeer(Qt3D::QNode *peer)
+void Texture::updateFromPeer(Qt3D::QNode *peer)
 {
     QAbstractTextureProvider *texture = static_cast<QAbstractTextureProvider *>(peer);
 
@@ -150,7 +150,7 @@ void RenderTexture::updateFromPeer(Qt3D::QNode *peer)
 }
 
 // RenderTread
-QOpenGLTexture *RenderTexture::getOrCreateGLTexture()
+QOpenGLTexture *Texture::getOrCreateGLTexture()
 {
     // m_gl HAS to be destroyed in the OpenGL Thread
     // Will be recreated with updated values the next time
@@ -223,7 +223,7 @@ QOpenGLTexture *RenderTexture::getOrCreateGLTexture()
 }
 
 // RenderThread
-QOpenGLTexture *RenderTexture::buildGLTexture()
+QOpenGLTexture *Texture::buildGLTexture()
 {
     QOpenGLContext *ctx = QOpenGLContext::currentContext();
     if (!ctx) {
@@ -298,7 +298,7 @@ QOpenGLTexture *RenderTexture::buildGLTexture()
 }
 
 // RenderThread
-void RenderTexture::setToGLTexture(RenderTextureImage *rImg, TexImageData *imgData)
+void Texture::setToGLTexture(RenderTextureImage *rImg, TexImageData *imgData)
 {
     Q_ASSERT(m_gl && m_gl->isCreated() && m_gl->isStorageAllocated());
     // ensure we don't accidently cause a detach / copy of the raw bytes
@@ -332,7 +332,7 @@ void RenderTexture::setToGLTexture(RenderTextureImage *rImg, TexImageData *imgDa
 }
 
 // RenderThread
-void RenderTexture::updateWrapAndFilters()
+void Texture::updateWrapAndFilters()
 {
     m_gl->setWrapMode(QOpenGLTexture::DirectionS, static_cast<QOpenGLTexture::WrapMode>(m_wrapModeX));
     if (m_target != QAbstractTextureProvider::Target1D &&
@@ -351,7 +351,7 @@ void RenderTexture::updateWrapAndFilters()
     }
 }
 
-void RenderTexture::updateDNA()
+void Texture::updateDNA()
 {
     int key = m_width + m_height + m_depth + m_layers +
                          (m_generateMipMaps ? 1 : 0) +
@@ -375,19 +375,19 @@ void RenderTexture::updateDNA()
 }
 
 // RenderThread
-GLint RenderTexture::textureId()
+GLint Texture::textureId()
 {
     return getOrCreateGLTexture()->textureId();
 }
 
 // Any Thread
-bool RenderTexture::isTextureReset() const
+bool Texture::isTextureReset() const
 {
     QMutexLocker lock(m_lock);
     return m_isDirty;
 }
 
-void RenderTexture::setSize(int width, int height, int depth)
+void Texture::setSize(int width, int height, int depth)
 {
     if (width != m_width) {
         m_width = width;
@@ -403,7 +403,7 @@ void RenderTexture::setSize(int width, int height, int depth)
     }
 }
 
-void RenderTexture::setFormat(QAbstractTextureProvider::TextureFormat format)
+void Texture::setFormat(QAbstractTextureProvider::TextureFormat format)
 {
     if (format != m_format) {
         m_format = format;
@@ -412,7 +412,7 @@ void RenderTexture::setFormat(QAbstractTextureProvider::TextureFormat format)
 }
 
 // ChangeArbiter/Aspect Thread
-void RenderTexture::sceneChangeEvent(const Qt3D::QSceneChangePtr &e)
+void Texture::sceneChangeEvent(const Qt3D::QSceneChangePtr &e)
 {
     // The QOpenGLTexture has to be manipulated from the RenderThread only
     QMutexLocker lock(m_lock);
@@ -503,30 +503,30 @@ void RenderTexture::sceneChangeEvent(const Qt3D::QSceneChangePtr &e)
     }
 }
 
-TextureDNA RenderTexture::dna() const
+TextureDNA Texture::dna() const
 {
     return m_textureDNA;
 }
 
 // AspectThread
-void RenderTexture::setTextureManager(TextureManager *manager)
+void Texture::setTextureManager(TextureManager *manager)
 {
     m_textureManager = manager;
 }
 
 // AspectThread
-void RenderTexture::setTextureImageManager(TextureImageManager *manager)
+void Texture::setTextureImageManager(TextureImageManager *manager)
 {
     m_textureImageManager = manager;
 }
 
-void RenderTexture::setTextureDataManager(TextureDataManager *manager)
+void Texture::setTextureDataManager(TextureDataManager *manager)
 {
     m_textureDataManager = manager;
 }
 
 // RenderThread
-void RenderTexture::updateAndLoadTextureImage()
+void Texture::updateAndLoadTextureImage()
 {
     QVector<TextureImageDNA> dnas;
     Q_FOREACH (HTextureImage t, m_textureImages) {
@@ -547,17 +547,17 @@ void RenderTexture::updateAndLoadTextureImage()
     m_dataUploadRequired = false;
 }
 
-void RenderTexture::addTextureImageData(HTextureImage handle)
+void Texture::addTextureImageData(HTextureImage handle)
 {
     m_textureImages.append(handle);
 }
 
-void RenderTexture::removeTextureImageData(HTextureImage handle)
+void Texture::removeTextureImageData(HTextureImage handle)
 {
     m_textureImages.removeOne(handle);
 }
 
-void RenderTexture::requestTextureDataUpdate()
+void Texture::requestTextureDataUpdate()
 {
     m_dataUploadRequired = true;
 }
@@ -565,12 +565,12 @@ void RenderTexture::requestTextureDataUpdate()
 // Will request a new jobs, if one of the texture data has changed
 // after the job was executed, requestTextureDataUpdate will be called
 // Called by RenderTextureImages
-void RenderTexture::addToPendingTextureJobs()
+void Texture::addToPendingTextureJobs()
 {
     m_textureDataManager->addToPendingTextures(peerUuid());
 }
 
-RenderTextureFunctor::RenderTextureFunctor(TextureManager *textureManager,
+TextureFunctor::TextureFunctor(TextureManager *textureManager,
                                            TextureImageManager *textureImageManager,
                                            TextureDataManager *textureDataManager)
     : m_textureManager(textureManager)
@@ -579,9 +579,9 @@ RenderTextureFunctor::RenderTextureFunctor(TextureManager *textureManager,
 {
 }
 
-Qt3D::QBackendNode *RenderTextureFunctor::create(Qt3D::QNode *frontend, const Qt3D::QBackendNodeFactory *factory) const
+Qt3D::QBackendNode *TextureFunctor::create(Qt3D::QNode *frontend, const Qt3D::QBackendNodeFactory *factory) const
 {
-    RenderTexture *backend = m_textureManager->getOrCreateResource(frontend->id());
+    Texture *backend = m_textureManager->getOrCreateResource(frontend->id());
     backend->setFactory(factory);
     backend->setTextureManager(m_textureManager);
     backend->setTextureImageManager(m_textureImageManager);
@@ -590,12 +590,12 @@ Qt3D::QBackendNode *RenderTextureFunctor::create(Qt3D::QNode *frontend, const Qt
     return backend;
 }
 
-Qt3D::QBackendNode *RenderTextureFunctor::get(const Qt3D::QNodeId &id) const
+Qt3D::QBackendNode *TextureFunctor::get(const Qt3D::QNodeId &id) const
 {
     return m_textureManager->lookupResource(id);
 }
 
-void RenderTextureFunctor::destroy(const Qt3D::QNodeId &id) const
+void TextureFunctor::destroy(const Qt3D::QNodeId &id) const
 {
     m_textureManager->releaseResource(id);
 }
diff --git a/src/render/backend/rendertexture_p.h b/src/render/backend/texture_p.h
index 1764ef35a..1a8251351 100644
--- a/src/render/backend/rendertexture_p.h
+++ b/src/render/backend/texture_p.h
@@ -34,8 +34,8 @@
 **
 ****************************************************************************/
 
-#ifndef QT3DRENDER_RENDER_RENDERTEXTURE_H
-#define QT3DRENDER_RENDER_RENDERTEXTURE_H
+#ifndef QT3DRENDER_RENDER_TEXTURE_H
+#define QT3DRENDER_RENDER_TEXTURE_H
 
 #include <QOpenGLContext>
 #include <QMutex>
@@ -60,11 +60,11 @@ class TextureDataManager;
 
 typedef uint TextureDNA;
 
-class RenderTexture : public Qt3D::QBackendNode
+class Texture : public Qt3D::QBackendNode
 {
 public:
-    RenderTexture();
-    ~RenderTexture();
+    Texture();
+    ~Texture();
     void cleanup();
 
     void updateFromPeer(Qt3D::QNode *peer) Q_DECL_OVERRIDE;
@@ -134,10 +134,10 @@ private:
     void updateDNA();
 };
 
-class RenderTextureFunctor : public Qt3D::QBackendNodeFunctor
+class TextureFunctor : public Qt3D::QBackendNodeFunctor
 {
 public:
-    explicit RenderTextureFunctor(TextureManager *textureManager,
+    explicit TextureFunctor(TextureManager *textureManager,
                                   TextureImageManager *textureImageManager,
                                   TextureDataManager *textureDataManager);
 
@@ -156,6 +156,6 @@ private:
 
 QT_END_NAMESPACE
 
-Q_DECLARE_METATYPE(Qt3DRender::Render::RenderTexture*)
+Q_DECLARE_METATYPE(Qt3DRender::Render::Texture*)
 
-#endif // QT3DRENDER_RENDER_RENDERTEXTURE_H
+#endif // QT3DRENDER_RENDER_TEXTURE_H