QTexture renamed to QAbstractTextureProvider

This is done prior to the whole texture API refactoring.

Doc was also added, might need improvement later on but a base is present at
least.

Change-Id: I75589f14dfbfba7bc4250b2e0960670e020ed38a
Reviewed-by: Sean Harmer <sean.harmer@kdab.com>

42 files changed, 464 insertions, 341 deletions

diff --git a/examples/deferred-renderer-cpp/gbuffer.cpp b/examples/deferred-renderer-cpp/gbuffer.cpp
index 4ed1a627f..4004a4d36 100644
--- a/examples/deferred-renderer-cpp/gbuffer.cpp
+++ b/examples/deferred-renderer-cpp/gbuffer.cpp
@@ -44,11 +44,11 @@
 GBuffer::GBuffer(Qt3D::QNode *parent)
     : Qt3D::QRenderTarget(parent)
 {
-    const Qt3D::QTexture::TextureFormat formats[AttachmentsCount] = {
-        Qt3D::QTexture::RGBA32F,
-        Qt3D::QTexture::RGB32F,
-        Qt3D::QTexture::RGB16F,
-        Qt3D::QTexture::D32F
+    const Qt3D::QAbstractTextureProvider::TextureFormat formats[AttachmentsCount] = {
+        Qt3D::QAbstractTextureProvider::RGBA32F,
+        Qt3D::QAbstractTextureProvider::RGB32F,
+        Qt3D::QAbstractTextureProvider::RGB16F,
+        Qt3D::QAbstractTextureProvider::D32F
     };
 
     const Qt3D::QRenderAttachment::RenderAttachmentType attachmentTypes[AttachmentsCount] = {
@@ -68,14 +68,14 @@ GBuffer::GBuffer(Qt3D::QNode *parent)
     for (int i = 0; i < AttachmentsCount; i++) {
         Qt3D::QRenderAttachment *attachment = new Qt3D::QRenderAttachment(this);
 
-        m_textures[i] = new Qt3D::QTexture(Qt3D::QTexture::Target2D);
+        m_textures[i] = new Qt3D::QAbstractTextureProvider(Qt3D::QAbstractTextureProvider::Target2D);
         m_textures[i]->setFormat(formats[i]);
         m_textures[i]->setWidth(1024);
         m_textures[i]->setHeight(1024);
         m_textures[i]->setGenerateMipMaps(false);
         m_textures[i]->setWrapMode(Qt3D::QTextureWrapMode(Qt3D::QTextureWrapMode::ClampToEdge));
-        m_textures[i]->setMinificationFilter(Qt3D::QTexture::Linear);
-        m_textures[i]->setMagnificationFilter(Qt3D::QTexture::Linear);
+        m_textures[i]->setMinificationFilter(Qt3D::QAbstractTextureProvider::Linear);
+        m_textures[i]->setMagnificationFilter(Qt3D::QAbstractTextureProvider::Linear);
 
         attachment->setTexture(m_textures[i]);
         attachment->setType(attachmentTypes[i]);
@@ -85,22 +85,22 @@ GBuffer::GBuffer(Qt3D::QNode *parent)
     }
 }
 
-Qt3D::QTexture *GBuffer::colorTexture() const
+Qt3D::QAbstractTextureProvider *GBuffer::colorTexture() const
 {
     return m_textures[Color];
 }
 
-Qt3D::QTexture *GBuffer::positionTexture() const
+Qt3D::QAbstractTextureProvider *GBuffer::positionTexture() const
 {
     return m_textures[Position];
 }
 
-Qt3D::QTexture *GBuffer::normalTexture() const
+Qt3D::QAbstractTextureProvider *GBuffer::normalTexture() const
 {
     return m_textures[Normal];
 }
 
-Qt3D::QTexture *GBuffer::depthTexture() const
+Qt3D::QAbstractTextureProvider *GBuffer::depthTexture() const
 {
     return m_textures[Depth];
 }
diff --git a/examples/deferred-renderer-cpp/gbuffer.h b/examples/deferred-renderer-cpp/gbuffer.h
index 67e42886d..ee9a86515 100644
--- a/examples/deferred-renderer-cpp/gbuffer.h
+++ b/examples/deferred-renderer-cpp/gbuffer.h
@@ -59,13 +59,13 @@ public:
         AttachmentsCount
     };
 
-    Qt3D::QTexture *colorTexture() const;
-    Qt3D::QTexture *positionTexture() const;
-    Qt3D::QTexture *normalTexture() const;
-    Qt3D::QTexture *depthTexture() const;
+    Qt3D::QAbstractTextureProvider *colorTexture() const;
+    Qt3D::QAbstractTextureProvider *positionTexture() const;
+    Qt3D::QAbstractTextureProvider *normalTexture() const;
+    Qt3D::QAbstractTextureProvider *depthTexture() const;
 
 private:
-    Qt3D::QTexture *m_textures[AttachmentsCount];
+    Qt3D::QAbstractTextureProvider *m_textures[AttachmentsCount];
     Qt3D::QRenderAttachment *m_attachments[AttachmentsCount];
 };
 
diff --git a/examples/materials-cpp/barrel.cpp b/examples/materials-cpp/barrel.cpp
index 3af8bac89..1f2bba90d 100644
--- a/examples/materials-cpp/barrel.cpp
+++ b/examples/materials-cpp/barrel.cpp
@@ -140,8 +140,8 @@ void Barrel::setNormalTextureSource()
     QImage img;
     if (img.load(QStringLiteral(":/assets/metalbarrel/normal_") + bumpsName[m_bumps] + QStringLiteral(".webp"))) {
         m_normalTexture->setFormat(img.hasAlphaChannel() ?
-                                       Qt3D::QTexture::RGBA8_UNorm :
-                                       Qt3D::QTexture::RGB8_UNorm);
+                                       Qt3D::QAbstractTextureProvider::RGBA8_UNorm :
+                                       Qt3D::QAbstractTextureProvider::RGB8_UNorm);
         m_normalTexture->setFromQImage(img);
     }
 }
@@ -151,8 +151,8 @@ void Barrel::setDiffuseTextureSource()
     QImage img;
     if (img.load(QStringLiteral(":/assets/metalbarrel/diffus_") + diffuseColorsName[m_diffuseColor] + QStringLiteral(".webp"))) {
         m_diffuseTexture->setFormat(img.hasAlphaChannel() ?
-                                       Qt3D::QTexture::RGBA8_UNorm :
-                                       Qt3D::QTexture::RGB8_UNorm);
+                                       Qt3D::QAbstractTextureProvider::RGBA8_UNorm :
+                                       Qt3D::QAbstractTextureProvider::RGB8_UNorm);
         m_diffuseTexture->setFromQImage(img);
     }
 }
@@ -162,8 +162,8 @@ void Barrel::setSpecularTextureSource()
     QImage img;
     if (img.load(QStringLiteral(":/assets/metalbarrel/specular") + specularColorsName[m_specularColor] + QStringLiteral(".webp"))) {
         m_specularTexture->setFormat(img.hasAlphaChannel() ?
-                                       Qt3D::QTexture::RGBA8_UNorm :
-                                       Qt3D::QTexture::RGB8_UNorm);
+                                       Qt3D::QAbstractTextureProvider::RGBA8_UNorm :
+                                       Qt3D::QAbstractTextureProvider::RGB8_UNorm);
         m_specularTexture->setFromQImage(img);
     }
 }
diff --git a/examples/materials-cpp/barrel.h b/examples/materials-cpp/barrel.h
index 6fcdb434b..0117f7451 100644
--- a/examples/materials-cpp/barrel.h
+++ b/examples/materials-cpp/barrel.h
@@ -88,9 +88,9 @@ private:
     DiffuseColor m_diffuseColor;
     SpecularColor m_specularColor;
     Qt3D::QNormalDiffuseSpecularMapMaterial *m_material;
-    Qt3D::QTexture *m_diffuseTexture;
-    Qt3D::QTexture *m_normalTexture;
-    Qt3D::QTexture *m_specularTexture;
+    Qt3D::QAbstractTextureProvider *m_diffuseTexture;
+    Qt3D::QAbstractTextureProvider *m_normalTexture;
+    Qt3D::QAbstractTextureProvider *m_specularTexture;
 
     void setNormalTextureSource();
     void setDiffuseTextureSource();
diff --git a/examples/materials-cpp/houseplant.cpp b/examples/materials-cpp/houseplant.cpp
index 5b6b66857..100c3f0c8 100644
--- a/examples/materials-cpp/houseplant.cpp
+++ b/examples/materials-cpp/houseplant.cpp
@@ -81,26 +81,26 @@ HousePlant::HousePlant(Qt3D::QNode *parent)
 
     if (img.load(QStringLiteral(":/assets/houseplants/cover.webp"))) {
         m_coverMaterial->diffuse()->setFormat(img.hasAlphaChannel() ?
-                                                  Qt3D::QTexture::RGBA8_UNorm :
-                                                  Qt3D::QTexture::RGB8_UNorm);
+                                                  Qt3D::QAbstractTextureProvider::RGBA8_UNorm :
+                                                  Qt3D::QAbstractTextureProvider::RGB8_UNorm);
         m_coverMaterial->diffuse()->setFromQImage(img);
     }
     if (img.load(QStringLiteral(":/assets/houseplants/cover_normal.webp"))) {
         m_coverMaterial->normal()->setFormat(img.hasAlphaChannel() ?
-                                                  Qt3D::QTexture::RGBA8_UNorm :
-                                                  Qt3D::QTexture::RGB8_UNorm);
+                                                  Qt3D::QAbstractTextureProvider::RGBA8_UNorm :
+                                                  Qt3D::QAbstractTextureProvider::RGB8_UNorm);
         m_coverMaterial->normal()->setFromQImage(img);
     }
     if (img.load(QStringLiteral(":/assets/houseplants/pot.webp"))) {
         m_potMaterial->diffuse()->setFormat(img.hasAlphaChannel() ?
-                                                 Qt3D::QTexture::RGBA8_UNorm :
-                                                 Qt3D::QTexture::RGB8_UNorm);
+                                                 Qt3D::QAbstractTextureProvider::RGBA8_UNorm :
+                                                 Qt3D::QAbstractTextureProvider::RGB8_UNorm);
         m_potMaterial->diffuse()->setFromQImage(img);
     }
     if (img.load(QStringLiteral(":/assets/houseplants/pot_normal.webp"))) {
         m_potMaterial->normal()->setFormat(img.hasAlphaChannel() ?
-                                                 Qt3D::QTexture::RGBA8_UNorm :
-                                                 Qt3D::QTexture::RGB8_UNorm);
+                                                 Qt3D::QAbstractTextureProvider::RGBA8_UNorm :
+                                                 Qt3D::QAbstractTextureProvider::RGB8_UNorm);
         m_potMaterial->normal()->setFromQImage(img);
     }
 
@@ -195,14 +195,14 @@ void HousePlant::updatePlantType()
     QImage img;
     if (img.load(QStringLiteral(":/assets/houseplants/") + plantNames[m_plantType] + QStringLiteral(".webp"))) {
         m_plantMaterial->diffuse()->setFormat(img.hasAlphaChannel() ?
-                                                  Qt3D::QTexture::RGBA8_UNorm :
-                                                  Qt3D::QTexture::RGB8_UNorm);
+                                                  Qt3D::QAbstractTextureProvider::RGBA8_UNorm :
+                                                  Qt3D::QAbstractTextureProvider::RGB8_UNorm);
         m_plantMaterial->diffuse()->setFromQImage(img);
     }
     if (img.load(QStringLiteral(":/assets/houseplants/") + plantNames[m_plantType] + QStringLiteral("_normal.webp"))) {
         m_plantMaterial->normal()->setFormat(img.hasAlphaChannel() ?
-                                                  Qt3D::QTexture::RGBA8_UNorm :
-                                                  Qt3D::QTexture::RGB8_UNorm);
+                                                  Qt3D::QAbstractTextureProvider::RGBA8_UNorm :
+                                                  Qt3D::QAbstractTextureProvider::RGB8_UNorm);
         m_plantMaterial->normal()->setFromQImage(img);
     }
 }
diff --git a/examples/materials-cpp/main.cpp b/examples/materials-cpp/main.cpp
index c7ae96d76..06ee463f3 100644
--- a/examples/materials-cpp/main.cpp
+++ b/examples/materials-cpp/main.cpp
@@ -111,22 +111,22 @@ int main(int argc, char* argv[])
     // Providing image loaders for textures would make sense
     if (img.load(QStringLiteral(":/assets/textures/pattern_09/diffuse.webp"))) {
         normalDiffuseSpecularMapMaterial->diffuse()->setFormat(img.hasAlphaChannel() ?
-                                                                   Qt3D::QTexture::RGBA8_UNorm :
-                                                                   Qt3D::QTexture::RGB8_UNorm);
+                                                                   Qt3D::QAbstractTextureProvider::RGBA8_UNorm :
+                                                                   Qt3D::QAbstractTextureProvider::RGB8_UNorm);
         normalDiffuseSpecularMapMaterial->diffuse()->setFromQImage(img);
     }
 
     if (img.load(QStringLiteral(":/assets/textures/pattern_09/specular.webp"))) {
         normalDiffuseSpecularMapMaterial->specular()->setFormat(img.hasAlphaChannel() ?
-                                                                    Qt3D::QTexture::RGBA8_UNorm :
-                                                                    Qt3D::QTexture::RGB8_UNorm);
+                                                                    Qt3D::QAbstractTextureProvider::RGBA8_UNorm :
+                                                                    Qt3D::QAbstractTextureProvider::RGB8_UNorm);
         normalDiffuseSpecularMapMaterial->specular()->setFromQImage(img);
     }
 
     if (img.load(QStringLiteral(":/assets/textures/pattern_09/normal.webp"))) {
         normalDiffuseSpecularMapMaterial->normal()->setFormat(img.hasAlphaChannel() ?
-                                                                  Qt3D::QTexture::RGBA8_UNorm :
-                                                                  Qt3D::QTexture::RGB8_UNorm);
+                                                                  Qt3D::QAbstractTextureProvider::RGBA8_UNorm :
+                                                                  Qt3D::QAbstractTextureProvider::RGB8_UNorm);
         normalDiffuseSpecularMapMaterial->normal()->setFromQImage(img);
     }
     planeEntity->addComponent(normalDiffuseSpecularMapMaterial);
@@ -141,8 +141,8 @@ int main(int argc, char* argv[])
 
     if (img.load(QStringLiteral(":/assets/chest/diffuse.webp"))) {
         diffuseMapMaterial->diffuse()->setFormat(img.hasAlphaChannel() ?
-                                                     Qt3D::QTexture::RGBA8_UNorm :
-                                                     Qt3D::QTexture::RGB8_UNorm);
+                                                     Qt3D::QAbstractTextureProvider::RGBA8_UNorm :
+                                                     Qt3D::QAbstractTextureProvider::RGB8_UNorm);
         diffuseMapMaterial->diffuse()->setFromQImage(img);
     }
     chest->addComponent(diffuseMapMaterial);
diff --git a/src/plugins/sceneparsers/assimp/assimpparser.cpp b/src/plugins/sceneparsers/assimp/assimpparser.cpp
index 3c1dab23b..ea11e3b15 100644
--- a/src/plugins/sceneparsers/assimp/assimpparser.cpp
+++ b/src/plugins/sceneparsers/assimp/assimpparser.cpp
@@ -593,7 +593,7 @@ void AssimpParser::loadMesh(uint meshIndex)
 void AssimpParser::loadEmbeddedTexture(uint textureIndex)
 {
     aiTexture *assimpTexture = m_scene->m_aiScene->mTextures[textureIndex];
-    QTexture *texture = new QTexture(QTexture::Target2D);
+    QAbstractTextureProvider *texture = new QAbstractTextureProvider(QAbstractTextureProvider::Target2D);
     TexImageDataPtr textureData(new TexImageData(0, 0));
 
     bool isCompressed = assimpTexture->mHeight == 0;
@@ -773,7 +773,7 @@ void AssimpParser::copyMaterialTextures(QMaterial *material, aiMaterial *assimpM
             // Load texture if not already loaded
             bool textureLoaded = true;
             if (!m_scene->m_materialTextures.contains(fullPath)) {
-                QTexture *tex = new QTexture(QTexture::Target2D);
+                QAbstractTextureProvider *tex = new QAbstractTextureProvider(QAbstractTextureProvider::Target2D);
                 QImage textureImage;
                 if (!textureImage.load(fullPath) || !textureImage.isNull()) {
                     tex->setFromQImage(textureImage);
diff --git a/src/plugins/sceneparsers/assimp/assimpparser_p.h b/src/plugins/sceneparsers/assimp/assimpparser_p.h
index ce9d61c9f..76be4d2d9 100644
--- a/src/plugins/sceneparsers/assimp/assimpparser_p.h
+++ b/src/plugins/sceneparsers/assimp/assimpparser_p.h
@@ -66,7 +66,7 @@ class QMaterial;
 class QShaderProgram;
 class QEffect;
 class QCamera;
-class QTexture;
+class QAbstractTextureProvider;
 class QMesh;
 class AssimpMesh;
 
@@ -132,8 +132,8 @@ private :
         QMap<uint, AssimpMesh *> m_meshes;
         QMap<uint, QMaterial*> m_materials;
         QMap<uint, QEffect *> m_effects;
-        QMap<uint, QTexture*> m_embeddedTextures;
-        QMap<QString, QTexture*> m_materialTextures;
+        QMap<uint, QAbstractTextureProvider *> m_embeddedTextures;
+        QMap<QString, QAbstractTextureProvider *> m_materialTextures;
         QMap<aiNode*, QEntity*> m_cameras;
         QHash<aiTextureType, QString> m_textureToParameterName;
 //    QMap<aiNode*, Light*> m_lights;
diff --git a/src/quick3d/imports/render/qt3dquick3drenderplugin.cpp b/src/quick3d/imports/render/qt3dquick3drenderplugin.cpp
index 15b36b56b..0e6624c31 100644
--- a/src/quick3d/imports/render/qt3dquick3drenderplugin.cpp
+++ b/src/quick3d/imports/render/qt3dquick3drenderplugin.cpp
@@ -180,7 +180,7 @@ void Qt3DQuick3DRenderPlugin::registerTypes(const char *uri)
 
     // Textures
     qmlRegisterType<Qt3D::QTextureWrapMode>(uri, 2, 0, "WrapMode");//, QStringLiteral("QTextureWrapMode cannot be created from QML"));
-    qmlRegisterUncreatableType<Qt3D::QTexture>(uri, 2, 0, "Texture", QStringLiteral("Texture should be created from one of the subclasses"));
+    qmlRegisterUncreatableType<Qt3D::QAbstractTextureProvider>(uri, 2, 0, "Texture", QStringLiteral("Texture should be created from one of the subclasses"));
     qmlRegisterType<Qt3D::Render::Quick::Quick3DTexture1D>(uri, 2, 0, "Texture1D");
     qmlRegisterType<Qt3D::Render::Quick::Quick3DTexture1DArray>(uri, 2, 0, "Texture1DArray");
     qmlRegisterExtendedType<Qt3D::Render::Quick::Quick3DTexture2D, Qt3D::Render::Quick::Quick3DTexture2DExtension>(uri, 2, 0, "Texture2D");
diff --git a/src/quick3d/quick3drenderer/items/quick3dtexture.cpp b/src/quick3d/quick3drenderer/items/quick3dtexture.cpp
index 45484e25b..a93bde00c 100644
--- a/src/quick3d/quick3drenderer/items/quick3dtexture.cpp
+++ b/src/quick3d/quick3drenderer/items/quick3dtexture.cpp
@@ -51,57 +51,57 @@ namespace Render {
 namespace Quick {
 
 Quick3DTexture1D::Quick3DTexture1D(QNode *parent)
-    : QTexture(Target1D, parent)
+    : QAbstractTextureProvider(Target1D, parent)
 {
 }
 
 Quick3DTexture1DArray::Quick3DTexture1DArray(QNode *parent)
-    : QTexture(Target1DArray, parent)
+    : QAbstractTextureProvider(Target1DArray, parent)
 {
 }
 
 Quick3DTexture2D::Quick3DTexture2D(QNode *parent)
-    : QTexture(Target2D, parent)
+    : QAbstractTextureProvider(Target2D, parent)
 {
 }
 
 Quick3DTexture2DArray::Quick3DTexture2DArray(QNode *parent)
-    : QTexture(Target2DArray, parent)
+    : QAbstractTextureProvider(Target2DArray, parent)
 {
 }
 
 Quick3DTexture3D::Quick3DTexture3D(QNode *parent)
-    : QTexture(Target3D, parent)
+    : QAbstractTextureProvider(Target3D, parent)
 {
 }
 
 Quick3DTextureCubeMap::Quick3DTextureCubeMap(QNode *parent)
-    : QTexture(TargetCubeMap, parent)
+    : QAbstractTextureProvider(TargetCubeMap, parent)
 {
 }
 
 Quick3DTextureCubeMapArray::Quick3DTextureCubeMapArray(QNode *parent)
-    : QTexture(TargetCubeMapArray, parent)
+    : QAbstractTextureProvider(TargetCubeMapArray, parent)
 {
 }
 
 Quick3DTexture2DMultisample::Quick3DTexture2DMultisample(QNode *parent)
-    : QTexture(Target2DMultisample, parent)
+    : QAbstractTextureProvider(Target2DMultisample, parent)
 {
 }
 
 Quick3DTexture2DMultisampleArray::Quick3DTexture2DMultisampleArray(QNode *parent)
-    : QTexture(Target2DMultisampleArray, parent)
+    : QAbstractTextureProvider(Target2DMultisampleArray, parent)
 {
 }
 
 Quick3DTextureRectangle::Quick3DTextureRectangle(QNode *parent)
-    : QTexture(TargetRectangle, parent)
+    : QAbstractTextureProvider(TargetRectangle, parent)
 {
 }
 
 Quick3DTextureBuffer::Quick3DTextureBuffer(QNode *parent)
-    : QTexture(TargetBuffer, parent)
+    : QAbstractTextureProvider(TargetBuffer, parent)
 {
 }
 
@@ -126,8 +126,8 @@ void Quick3DTexture2DExtension::setSource(QUrl arg)
             QImage img;
             if (img.load(source)) {
                 parentTexture()->setFormat(img.hasAlphaChannel() ?
-                                               QTexture::RGBA8_UNorm :
-                                               QTexture::RGB8_UNorm);
+                                               QAbstractTextureProvider::RGBA8_UNorm :
+                                               QAbstractTextureProvider::RGB8_UNorm);
                 parentTexture()->setFromQImage(img);
             }
             else {
@@ -173,7 +173,7 @@ void Quick3DTextureCubeMapExtension::setPositiveX(const QUrl &positiveX)
     if (positiveX != m_positiveX) {
         m_positiveX = positiveX;
         emit positiveXChanged();
-        loadFace(positiveX, QTexture::CubeMapPositiveX);
+        loadFace(positiveX, QAbstractTextureProvider::CubeMapPositiveX);
     }
 }
 
@@ -182,7 +182,7 @@ void Quick3DTextureCubeMapExtension::setPositiveY(const QUrl &positiveY)
     if (positiveY != m_positiveY) {
         m_positiveY = positiveY;
         emit positiveYChanged();
-        loadFace(positiveY, QTexture::CubeMapPositiveY);
+        loadFace(positiveY, QAbstractTextureProvider::CubeMapPositiveY);
     }
 }
 
@@ -191,7 +191,7 @@ void Quick3DTextureCubeMapExtension::setPositiveZ(const QUrl &positiveZ)
     if (positiveZ != m_positiveZ) {
         m_positiveZ = positiveZ;
         emit positiveZChanged();
-        loadFace(positiveZ, QTexture::CubeMapPositiveZ);
+        loadFace(positiveZ, QAbstractTextureProvider::CubeMapPositiveZ);
     }
 }
 
@@ -200,7 +200,7 @@ void Quick3DTextureCubeMapExtension::setNegativeX(const QUrl &negativeX)
     if (negativeX != m_negativeX) {
         m_negativeX = negativeX;
         emit negativeXChanged();
-        loadFace(negativeX, QTexture::CubeMapNegativeX);
+        loadFace(negativeX, QAbstractTextureProvider::CubeMapNegativeX);
     }
 }
 
@@ -209,7 +209,7 @@ void Quick3DTextureCubeMapExtension::setNegativeY(const QUrl &negativeY)
     if (negativeY != m_negativeY) {
         m_negativeY = negativeY;
         emit negativeYChanged();
-        loadFace(negativeY, QTexture::CubeMapNegativeY);
+        loadFace(negativeY, QAbstractTextureProvider::CubeMapNegativeY);
     }
 }
 
@@ -218,7 +218,7 @@ void Quick3DTextureCubeMapExtension::setNegativeZ(const QUrl &negativeZ)
     if (negativeZ != m_negativeZ) {
         m_negativeZ = negativeZ;
         emit negativeZChanged();
-        loadFace(negativeZ, QTexture::CubeMapNegativeZ);
+        loadFace(negativeZ, QAbstractTextureProvider::CubeMapNegativeZ);
     }
 }
 
@@ -257,12 +257,12 @@ QUrl Quick3DTextureCubeMapExtension::negativeZ() const
     return m_negativeZ;
 }
 
-void Quick3DTextureCubeMapExtension::loadFace(const QUrl &faceUrl, QTexture::CubeMapFace face)
+void Quick3DTextureCubeMapExtension::loadFace(const QUrl &faceUrl, QAbstractTextureProvider::CubeMapFace face)
 {
     if (faceUrl.isLocalFile() || faceUrl.scheme() == QStringLiteral("qrc")) {
         QString source = faceUrl.toString().replace(QStringLiteral("qrc"), QStringLiteral(""));
         QImage img;
-        parentTexture()->setStatus(QTexture::Loading);
+        parentTexture()->setStatus(QAbstractTextureProvider::Loading);
         if (img.load(source)) {
             TexImageDataPtr dataPtr(new TexImageData(0, 0));
 
@@ -271,21 +271,21 @@ void Quick3DTextureCubeMapExtension::loadFace(const QUrl &faceUrl, QTexture::Cub
                 parentTexture()->setHeight(img.height());
             if (parentTexture()->width() != img.width())
                 parentTexture()->setWidth(img.width());
-            QTexture::TextureFormat format = img.hasAlphaChannel() ?
-                        QTexture::RGBA8_UNorm :
-                        QTexture::RGB8_UNorm;
+            QAbstractTextureProvider::TextureFormat format = img.hasAlphaChannel() ?
+                        QAbstractTextureProvider::RGBA8_UNorm :
+                        QAbstractTextureProvider::RGB8_UNorm;
             if (format != parentTexture()->format())
                 parentTexture()->setFormat(format);
             dataPtr->setImage(img);
             parentTexture()->addImageData(dataPtr);
-            parentTexture()->setStatus(QTexture::Loaded);
+            parentTexture()->setStatus(QAbstractTextureProvider::Loaded);
         }
         else {
             qWarning() << "Failed to load image : " << source;
-            parentTexture()->setStatus(QTexture::Error);
+            parentTexture()->setStatus(QAbstractTextureProvider::Error);
         }
     } else {
-        parentTexture()->setStatus(QTexture::Error);
+        parentTexture()->setStatus(QAbstractTextureProvider::Error);
         qWarning() << "implement loading from remote URLs";
     }
 }
diff --git a/src/quick3d/quick3drenderer/items/quick3dtexture.h b/src/quick3d/quick3drenderer/items/quick3dtexture.h
index fc4d8cb18..ef055692b 100644
--- a/src/quick3d/quick3drenderer/items/quick3dtexture.h
+++ b/src/quick3d/quick3drenderer/items/quick3dtexture.h
@@ -56,42 +56,42 @@ namespace Render {
 
 namespace Quick {
 
-class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTexture1D : public QTexture
+class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTexture1D : public QAbstractTextureProvider
 {
     Q_OBJECT
 public:
     explicit Quick3DTexture1D(QNode *parent = 0);
 };
 
-class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTexture1DArray : public QTexture
+class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTexture1DArray : public QAbstractTextureProvider
 {
     Q_OBJECT
 public:
     explicit Quick3DTexture1DArray(QNode *parent = 0);
 };
 
-class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTexture2D : public QTexture
+class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTexture2D : public QAbstractTextureProvider
 {
     Q_OBJECT
 public:
     explicit Quick3DTexture2D(QNode *parent = 0);
 };
 
-class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTexture2DArray : public QTexture
+class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTexture2DArray : public QAbstractTextureProvider
 {
     Q_OBJECT
 public:
     explicit Quick3DTexture2DArray(QNode *parent = 0);
 };
 
-class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTexture3D : public QTexture
+class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTexture3D : public QAbstractTextureProvider
 {
     Q_OBJECT
 public:
     explicit Quick3DTexture3D(QNode *parent = 0);
 };
 
-class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTextureCubeMap : public QTexture
+class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTextureCubeMap : public QAbstractTextureProvider
 {
     Q_OBJECT
 public:
@@ -100,35 +100,35 @@ public:
     friend class Quick3DTextureCubeMapExtension;
 };
 
-class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTextureCubeMapArray : public QTexture
+class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTextureCubeMapArray : public QAbstractTextureProvider
 {
     Q_OBJECT
 public:
     explicit Quick3DTextureCubeMapArray(QNode *parent = 0);
 };
 
-class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTexture2DMultisample : public QTexture
+class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTexture2DMultisample : public QAbstractTextureProvider
 {
     Q_OBJECT
 public:
     explicit Quick3DTexture2DMultisample(QNode *parent = 0);
 };
 
-class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTexture2DMultisampleArray : public QTexture
+class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTexture2DMultisampleArray : public QAbstractTextureProvider
 {
     Q_OBJECT
 public:
     explicit Quick3DTexture2DMultisampleArray(QNode *parent = 0);
 };
 
-class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTextureRectangle : public QTexture
+class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTextureRectangle : public QAbstractTextureProvider
 {
     Q_OBJECT
 public:
     explicit Quick3DTextureRectangle(QNode *parent = 0);
 };
 
-class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTextureBuffer : public QTexture
+class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTextureBuffer : public QAbstractTextureProvider
 {
     Q_OBJECT
 public:
@@ -150,7 +150,7 @@ Q_SIGNALS:
 
 private:
     QUrl m_source;
-    inline Qt3D::QTexture *parentTexture() const { return qobject_cast<Qt3D::QTexture *>(parent()); }
+    inline Qt3D::QAbstractTextureProvider *parentTexture() const { return qobject_cast<Qt3D::QAbstractTextureProvider *>(parent()); }
 };
 
 class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTextureCubeMapExtension : public QObject
@@ -202,7 +202,7 @@ private:
     QUrl m_source;
 
     inline Quick3DTextureCubeMap *parentTexture() { return qobject_cast<Quick3DTextureCubeMap *>(parent()); }
-    void loadFace(const QUrl &faceUrl, QTexture::CubeMapFace face);
+    void loadFace(const QUrl &faceUrl, QAbstractTextureProvider::CubeMapFace face);
 };
 
 } // Quick
diff --git a/src/render/backend/qrenderaspect.cpp b/src/render/backend/qrenderaspect.cpp
index 4cdd8a0b1..1f2cd7175 100644
--- a/src/render/backend/qrenderaspect.cpp
+++ b/src/render/backend/qrenderaspect.cpp
@@ -190,7 +190,7 @@ void QRenderAspect::registerBackendTypes()
     registerBackendType<QTransform>(QBackendNodeFunctorPtr(new Render::RenderNodeFunctor<Render::RenderTransform, Render::TransformManager>(d->m_renderer->transformManager())));
     registerBackendType<QMaterial>(QBackendNodeFunctorPtr(new Render::RenderNodeFunctor<Render::RenderMaterial, Render::MaterialManager>(d->m_renderer->materialManager())));
     registerBackendType<QTechnique>(QBackendNodeFunctorPtr(new Render::RenderNodeFunctor<Render::RenderTechnique, Render::TechniqueManager>(d->m_renderer->techniqueManager())));
-    registerBackendType<QTexture>(QBackendNodeFunctorPtr(new Render::RenderNodeFunctor<Render::RenderTexture, Render::TextureManager>(d->m_renderer->textureManager())));
+    registerBackendType<QAbstractTextureProvider>(QBackendNodeFunctorPtr(new Render::RenderNodeFunctor<Render::RenderTexture, Render::TextureManager>(d->m_renderer->textureManager())));
     registerBackendType<QShaderProgram>(QBackendNodeFunctorPtr(new Render::RenderNodeFunctor<Render::RenderShader, Render::ShaderManager>(d->m_renderer->shaderManager())));
     registerBackendType<QEffect>(QBackendNodeFunctorPtr(new Render::RenderNodeFunctor<Render::RenderEffect, Render::EffectManager>(d->m_renderer->effectManager())));
     registerBackendType<QAnnotation>(QBackendNodeFunctorPtr(new Render::RenderNodeFunctor<Render::RenderAnnotation, Render::CriterionManager>(d->m_renderer->criterionManager())));
diff --git a/src/render/backend/renderparameter.cpp b/src/render/backend/renderparameter.cpp
index 71bcbbca2..adcacd4cd 100644
--- a/src/render/backend/renderparameter.cpp
+++ b/src/render/backend/renderparameter.cpp
@@ -105,7 +105,7 @@ QVariant RenderParameter::toBackendValue(const QVariant &value)
 
     if (node == Q_NULLPTR) {
         return value;
-    } else if (qobject_cast<QTexture*>(node)) {
+    } else if (qobject_cast<QAbstractTextureProvider*>(node)) {
         return QVariant::fromValue(m_textureManager->getOrCreateResource(node->id()));
     } else if (qobject_cast<QShaderData*>(node)) {
         return QVariant::fromValue(m_shaderDataManager->getOrCreateResource(node->id()));
diff --git a/src/render/backend/rendertexture.cpp b/src/render/backend/rendertexture.cpp
index 81bb1130d..fa897f39f 100644
--- a/src/render/backend/rendertexture.cpp
+++ b/src/render/backend/rendertexture.cpp
@@ -63,16 +63,16 @@ RenderTexture::RenderTexture()
     , m_height(1)
     , m_depth(1)
     , m_generateMipMaps(false)
-    , m_target(QTexture::Target2D)
-    , m_format(QTexture::RGBA8U)
-    , m_magnificationFilter(QTexture::Nearest)
-    , m_minificationFilter(QTexture::Nearest)
+    , m_target(QAbstractTextureProvider::Target2D)
+    , m_format(QAbstractTextureProvider::RGBA8U)
+    , m_magnificationFilter(QAbstractTextureProvider::Nearest)
+    , m_minificationFilter(QAbstractTextureProvider::Nearest)
     , m_wrapModeX(QTextureWrapMode::ClampToEdge)
     , m_wrapModeY(QTextureWrapMode::ClampToEdge)
     , m_wrapModeZ(QTextureWrapMode::ClampToEdge)
     , m_maximumAnisotropy(1.0f)
-    , m_comparisonFunction(QTexture::CompareLessEqual)
-    , m_comparisonMode(QTexture::CompareNone)
+    , m_comparisonFunction(QAbstractTextureProvider::CompareLessEqual)
+    , m_comparisonMode(QAbstractTextureProvider::CompareNone)
     , m_isDirty(false)
     , m_filtersAndWrapUpdated(false)
     , m_lock(new QMutex())
@@ -94,7 +94,7 @@ void RenderTexture::cleanup()
 
 void RenderTexture::updateFromPeer(QNode *peer)
 {
-    QTexture *texture = static_cast<QTexture *>(peer);
+    QAbstractTextureProvider *texture = static_cast<QAbstractTextureProvider *>(peer);
 
     QMutexLocker lock(m_lock);
     if (texture != Q_NULLPTR) {
@@ -233,13 +233,13 @@ void RenderTexture::setToGLTexture(TexImageDataPtr imgData)
 void RenderTexture::updateWrapAndFilters()
 {
     m_gl->setWrapMode(QOpenGLTexture::DirectionS, static_cast<QOpenGLTexture::WrapMode>(m_wrapModeX));
-    if (m_target != QTexture::Target1D &&
-            m_target != QTexture::Target1DArray &&
-            m_target != QTexture::TargetBuffer)
+    if (m_target != QAbstractTextureProvider::Target1D &&
+            m_target != QAbstractTextureProvider::Target1DArray &&
+            m_target != QAbstractTextureProvider::TargetBuffer)
         m_gl->setWrapMode(QOpenGLTexture::DirectionT, static_cast<QOpenGLTexture::WrapMode>(m_wrapModeY));
-    if (m_target == QTexture::Target3D ||
-            m_target == QTexture::TargetCubeMap ||
-            m_target == QTexture::TargetCubeMapArray)
+    if (m_target == QAbstractTextureProvider::Target3D ||
+            m_target == QAbstractTextureProvider::TargetCubeMap ||
+            m_target == QAbstractTextureProvider::TargetCubeMapArray)
         m_gl->setWrapMode(QOpenGLTexture::DirectionR, static_cast<QOpenGLTexture::WrapMode>(m_wrapModeZ));
     m_gl->setMinMagFilters(static_cast<QOpenGLTexture::Filter>(m_minificationFilter),
                            static_cast<QOpenGLTexture::Filter>(m_magnificationFilter));
@@ -290,12 +290,12 @@ void RenderTexture::sceneChangeEvent(const QSceneChangePtr &e)
             m_generateMipMaps = propertyChange->value().toBool();
             m_isDirty = (oldMipMaps != m_generateMipMaps);
         } else if (propertyChange->propertyName() == QByteArrayLiteral("minificationFilter")) {
-            QTexture::Filter oldMinFilter = m_minificationFilter;
-            m_minificationFilter = static_cast<QTexture::Filter>(propertyChange->value().toInt());
+            QAbstractTextureProvider::Filter oldMinFilter = m_minificationFilter;
+            m_minificationFilter = static_cast<QAbstractTextureProvider::Filter>(propertyChange->value().toInt());
             m_filtersAndWrapUpdated = (oldMinFilter != m_minificationFilter);
         } else if (propertyChange->propertyName() == QByteArrayLiteral("magnificationFilter")) {
-            QTexture::Filter oldMagFilter = m_magnificationFilter;
-            m_magnificationFilter = static_cast<QTexture::Filter>(propertyChange->value().toInt());
+            QAbstractTextureProvider::Filter oldMagFilter = m_magnificationFilter;
+            m_magnificationFilter = static_cast<QAbstractTextureProvider::Filter>(propertyChange->value().toInt());
             m_filtersAndWrapUpdated = (oldMagFilter != m_magnificationFilter);
         } else if (propertyChange->propertyName() == QByteArrayLiteral("wrapModeX")) {
             QTextureWrapMode::WrapMode oldWrapModeX = m_wrapModeX;
@@ -310,24 +310,24 @@ void RenderTexture::sceneChangeEvent(const QSceneChangePtr &e)
             m_wrapModeZ =static_cast<QTextureWrapMode::WrapMode>(propertyChange->value().toInt());
              m_filtersAndWrapUpdated = (oldWrapModeZ != m_wrapModeZ);
         } else if (propertyChange->propertyName() == QByteArrayLiteral("format")) {
-            QTexture::TextureFormat oldFormat = m_format;
-            m_format = static_cast<QTexture::TextureFormat>(propertyChange->value().toInt());
+            QAbstractTextureProvider::TextureFormat oldFormat = m_format;
+            m_format = static_cast<QAbstractTextureProvider::TextureFormat>(propertyChange->value().toInt());
             m_isDirty = (oldFormat != m_format);
         } else if (propertyChange->propertyName() == QByteArrayLiteral("target")) {
-            QTexture::Target oldTarget = m_target;
-            m_target = static_cast<QTexture::Target>(propertyChange->value().toInt());
+            QAbstractTextureProvider::Target oldTarget = m_target;
+            m_target = static_cast<QAbstractTextureProvider::Target>(propertyChange->value().toInt());
             m_isDirty = (oldTarget != m_target);
         } else if (propertyChange->propertyName() == QByteArrayLiteral("maximumAnisotropy")) {
             float oldMaximumAnisotropy = m_maximumAnisotropy;
             m_maximumAnisotropy = propertyChange->value().toFloat();
             m_filtersAndWrapUpdated = !qFuzzyCompare(oldMaximumAnisotropy, m_maximumAnisotropy);
         } else if (propertyChange->propertyName() == QByteArrayLiteral("comparisonFunction")) {
-            QTexture::ComparisonFunction oldComparisonFunction = m_comparisonFunction;
-            m_comparisonFunction = propertyChange->value().value<QTexture::ComparisonFunction>();
+            QAbstractTextureProvider::ComparisonFunction oldComparisonFunction = m_comparisonFunction;
+            m_comparisonFunction = propertyChange->value().value<QAbstractTextureProvider::ComparisonFunction>();
             m_filtersAndWrapUpdated = (oldComparisonFunction != m_comparisonFunction);
         } else if (propertyChange->propertyName() == QByteArrayLiteral("comparisonMode")) {
-            QTexture::ComparisonMode oldComparisonMode = m_comparisonMode;
-            m_comparisonMode = propertyChange->value().value<QTexture::ComparisonMode>();
+            QAbstractTextureProvider::ComparisonMode oldComparisonMode = m_comparisonMode;
+            m_comparisonMode = propertyChange->value().value<QAbstractTextureProvider::ComparisonMode>();
             m_filtersAndWrapUpdated = (oldComparisonMode != m_comparisonMode);
         }
     }
diff --git a/src/render/backend/rendertexture_p.h b/src/render/backend/rendertexture_p.h
index 0b4f781ac..cdd69d911 100644
--- a/src/render/backend/rendertexture_p.h
+++ b/src/render/backend/rendertexture_p.h
@@ -54,7 +54,7 @@ class QOpenGLTexture;
 
 namespace Qt3D {
 
-class QTexture;
+class QAbstractTextureProvider;
 
 namespace Render {
 
@@ -88,16 +88,16 @@ private:
     int m_height;
     int m_depth;
     bool m_generateMipMaps;
-    QTexture::Target m_target;
-    QTexture::TextureFormat m_format;
-    QTexture::Filter m_magnificationFilter;
-    QTexture::Filter m_minificationFilter;
+    QAbstractTextureProvider::Target m_target;
+    QAbstractTextureProvider::TextureFormat m_format;
+    QAbstractTextureProvider::Filter m_magnificationFilter;
+    QAbstractTextureProvider::Filter m_minificationFilter;
     QTextureWrapMode::WrapMode m_wrapModeX;
     QTextureWrapMode::WrapMode m_wrapModeY;
     QTextureWrapMode::WrapMode m_wrapModeZ;
     float m_maximumAnisotropy;
-    QTexture::ComparisonFunction m_comparisonFunction;
-    QTexture::ComparisonMode m_comparisonMode;
+    QAbstractTextureProvider::ComparisonFunction m_comparisonFunction;
+    QAbstractTextureProvider::ComparisonMode m_comparisonMode;
 
     QList<TexImageDataPtr> m_imageData;
     bool m_isDirty;
diff --git a/src/render/backend/rendertextureprovider.cpp b/src/render/backend/rendertextureprovider.cpp
index 219b75f28..14a3b6e0c 100644
--- a/src/render/backend/rendertextureprovider.cpp
+++ b/src/render/backend/rendertextureprovider.cpp
@@ -52,7 +52,7 @@ RenderTextureProvider::RenderTextureProvider()
 {
 }
 
-RenderTexturePtr RenderTextureProvider::get(QTexture *t)
+RenderTexturePtr RenderTextureProvider::get(QAbstractTextureProvider *t)
 {
     if (m_dict.contains(t))
         return m_dict.value(t);
diff --git a/src/render/backend/rendertextureprovider_p.h b/src/render/backend/rendertextureprovider_p.h
index 42b516148..28879e195 100644
--- a/src/render/backend/rendertextureprovider_p.h
+++ b/src/render/backend/rendertextureprovider_p.h
@@ -49,7 +49,7 @@ QT_BEGIN_NAMESPACE
 
 namespace Qt3D {
 
-class QTexture;
+class QAbstractTextureProvider;
 
 namespace Render {
 
@@ -61,9 +61,9 @@ class RenderTextureProvider
 public:
     RenderTextureProvider();
 
-    Render::RenderTexturePtr get(QTexture* t);
+    Render::RenderTexturePtr get(QAbstractTextureProvider* t);
 private:
-    QHash<QTexture*, Render::RenderTexturePtr> m_dict;
+    QHash<QAbstractTextureProvider*, Render::RenderTexturePtr> m_dict;
 };
 
 } // namespace Render
diff --git a/src/render/backend/texturedatamanager.cpp b/src/render/backend/texturedatamanager.cpp
index 627ee095f..528ade8e3 100644
--- a/src/render/backend/texturedatamanager.cpp
+++ b/src/render/backend/texturedatamanager.cpp
@@ -47,7 +47,7 @@ namespace Qt3D {
 
 namespace Render {
 
-void Qt3D::Render::TextureDataManager::addTextureData(Qt3D::QTexture *texture)
+void Qt3D::Render::TextureDataManager::addTextureData(Qt3D::QAbstractTextureProvider *texture)
 {
     if (!contains(texture->id()) && !m_texturesPending.contains(texture))
         m_texturesPending.append(texture);
diff --git a/src/render/backend/texturedatamanager_p.h b/src/render/backend/texturedatamanager_p.h
index 08b8fc38e..d920e5e59 100644
--- a/src/render/backend/texturedatamanager_p.h
+++ b/src/render/backend/texturedatamanager_p.h
@@ -64,13 +64,13 @@ class TextureDataManager : public QResourceManager<TexImageData,
 public:
     TextureDataManager() {}
 
-    void addTextureData(QTexture *texture);
+    void addTextureData(QAbstractTextureProvider *texture);
 
-    QList<QTexture *> texturesPending() const { return m_texturesPending; }
+    QList<QAbstractTextureProvider *> texturesPending() const { return m_texturesPending; }
     void clearTexturesPending() { m_texturesPending.clear(); }
 
 private:
-    QList<QTexture *> m_texturesPending;
+    QList<QAbstractTextureProvider *> m_texturesPending;
 };
 
 } // Render
diff --git a/src/render/defaults/qdiffusemapmaterial.cpp b/src/render/defaults/qdiffusemapmaterial.cpp
index d32633cc0..8b16b8f4a 100644
--- a/src/render/defaults/qdiffusemapmaterial.cpp
+++ b/src/render/defaults/qdiffusemapmaterial.cpp
@@ -60,7 +60,7 @@ namespace Qt3D {
 QDiffuseMapMaterialPrivate::QDiffuseMapMaterialPrivate(QDiffuseMapMaterial *qq)
     : QMaterialPrivate(qq)
     , m_diffuseMapEffect(new QEffect())
-    , m_diffuseTexture(new QTexture(QTexture::Target2D))
+    , m_diffuseTexture(new QAbstractTextureProvider(QAbstractTextureProvider::Target2D))
     , m_ambientParameter(new QParameter(QStringLiteral("ka"), QColor::fromRgbF(0.05f, 0.05f, 0.05f, 1.0f)))
     , m_diffuseParameter(new QParameter(QStringLiteral("diffuseTexture"), m_diffuseTexture))
     , m_specularParameter(new QParameter(QStringLiteral("ks"), QColor::fromRgbF(0.95f, 0.95f, 0.95f, 1.0f)))
@@ -77,8 +77,8 @@ QDiffuseMapMaterialPrivate::QDiffuseMapMaterialPrivate(QDiffuseMapMaterial *qq)
     , m_diffuseMapGL3Shader(new QShaderProgram())
     , m_diffuseMapGL2ES2Shader(new QShaderProgram())
  {
-    m_diffuseTexture->setMagnificationFilter(QTexture::Linear);
-    m_diffuseTexture->setMinificationFilter(QTexture::LinearMipMapLinear);
+    m_diffuseTexture->setMagnificationFilter(QAbstractTextureProvider::Linear);
+    m_diffuseTexture->setMinificationFilter(QAbstractTextureProvider::LinearMipMapLinear);
     m_diffuseTexture->setWrapMode(QTextureWrapMode(QTextureWrapMode::Repeat));
     m_diffuseTexture->setGenerateMipMaps(true);
     m_diffuseTexture->setMaximumAnisotropy(16.0f);
@@ -209,10 +209,10 @@ float QDiffuseMapMaterial::shininess() const
     the wrap mode is repeat, the maximum anisotropy is set to 16.0
     and mipmapping is enabled.
  */
-QTexture *QDiffuseMapMaterial::diffuse() const
+QAbstractTextureProvider *QDiffuseMapMaterial::diffuse() const
 {
     Q_D(const QDiffuseMapMaterial);
-    return d->m_diffuseParameter->value().value<QTexture *>();
+    return d->m_diffuseParameter->value().value<QAbstractTextureProvider *>();
 }
 
 /*!
@@ -259,7 +259,7 @@ void QDiffuseMapMaterial::setShininess(float shininess)
     \fn Qt3D::QDiffuseMapMaterial::setDiffuse(QTexture *diffuseMap)
     Sets the current diffuse map to \a diffuseMap.
  */
-void QDiffuseMapMaterial::setDiffuse(QTexture *diffuseMap)
+void QDiffuseMapMaterial::setDiffuse(QAbstractTextureProvider *diffuseMap)
 {
     Q_D(QDiffuseMapMaterial);
     d->m_diffuseParameter->setValue(QVariant::fromValue(diffuseMap));
diff --git a/src/render/defaults/qdiffusemapmaterial.h b/src/render/defaults/qdiffusemapmaterial.h
index 69eb0d33f..0f3d9cf51 100644
--- a/src/render/defaults/qdiffusemapmaterial.h
+++ b/src/render/defaults/qdiffusemapmaterial.h
@@ -50,7 +50,7 @@ QT_BEGIN_NAMESPACE
 namespace Qt3D {
 
 class QDiffuseMapMaterialPrivate;
-class QTexture;
+class QAbstractTextureProvider;
 
 class QT3DRENDERERSHARED_EXPORT QDiffuseMapMaterial : public QMaterial
 {
@@ -58,7 +58,7 @@ class QT3DRENDERERSHARED_EXPORT QDiffuseMapMaterial : public QMaterial
     Q_PROPERTY(QColor ambient READ ambient WRITE setAmbient NOTIFY ambientChanged)
     Q_PROPERTY(QColor specular READ specular WRITE setSpecular NOTIFY specularChanged)
     Q_PROPERTY(float shininess READ shininess WRITE setShininess NOTIFY shininessChanged)
-    Q_PROPERTY(QTexture *diffuse READ diffuse WRITE setDiffuse NOTIFY diffuseChanged)
+    Q_PROPERTY(QAbstractTextureProvider *diffuse READ diffuse WRITE setDiffuse NOTIFY diffuseChanged)
     Q_PROPERTY(float textureScale READ textureScale WRITE setTextureScale NOTIFY textureScaleChanged)
 
 public:
@@ -68,13 +68,13 @@ public:
     QColor ambient() const;
     QColor specular() const;
     float shininess() const;
-    QTexture *diffuse() const;
+    QAbstractTextureProvider *diffuse() const;
     float textureScale() const;
 
     void setAmbient(const QColor &color);
     void setSpecular(const QColor &specular);
     void setShininess(float shininess);
-    void setDiffuse(QTexture *diffuse);
+    void setDiffuse(QAbstractTextureProvider *diffuse);
     void setTextureScale(float textureScale);
 
 Q_SIGNALS:
diff --git a/src/render/defaults/qdiffusemapmaterial_p.h b/src/render/defaults/qdiffusemapmaterial_p.h
index 538128668..515094a3e 100644
--- a/src/render/defaults/qdiffusemapmaterial_p.h
+++ b/src/render/defaults/qdiffusemapmaterial_p.h
@@ -49,7 +49,7 @@ QT_BEGIN_NAMESPACE
 namespace Qt3D {
 
 class QEffect;
-class QTexture;
+class QAbstractTextureProvider;
 class QTechnique;
 class QParameter;
 class QShaderProgram;
@@ -65,7 +65,7 @@ class QDiffuseMapMaterialPrivate : public QMaterialPrivate
     void init();
 
     QEffect *m_diffuseMapEffect;
-    QTexture *m_diffuseTexture;
+    QAbstractTextureProvider *m_diffuseTexture;
     QParameter *m_ambientParameter;
     QParameter *m_diffuseParameter;
     QParameter *m_specularParameter;
diff --git a/src/render/defaults/qdiffusespecularmapmaterial.cpp b/src/render/defaults/qdiffusespecularmapmaterial.cpp
index 864d1ed22..ce0abe9f2 100644
--- a/src/render/defaults/qdiffusespecularmapmaterial.cpp
+++ b/src/render/defaults/qdiffusespecularmapmaterial.cpp
@@ -61,8 +61,8 @@ namespace Qt3D {
 QDiffuseSpecularMapMaterialPrivate::QDiffuseSpecularMapMaterialPrivate(QDiffuseSpecularMapMaterial *qq)
     : QMaterialPrivate(qq)
     , m_diffuseSpecularMapEffect(new QEffect())
-    , m_diffuseTexture(new QTexture(QTexture::Target2D))
-    , m_specularTexture(new QTexture(QTexture::Target2D))
+    , m_diffuseTexture(new QAbstractTextureProvider(QAbstractTextureProvider::Target2D))
+    , m_specularTexture(new QAbstractTextureProvider(QAbstractTextureProvider::Target2D))
     , m_ambientParameter(new QParameter(QStringLiteral("ka"), QColor::fromRgbF(0.05f, 0.05f, 0.05f, 1.0f)))
     , m_diffuseParameter(new QParameter(QStringLiteral("diffuseTexture"), m_diffuseTexture))
     , m_specularParameter(new QParameter(QStringLiteral("specularTexture"), m_specularTexture))
@@ -79,14 +79,14 @@ QDiffuseSpecularMapMaterialPrivate::QDiffuseSpecularMapMaterialPrivate(QDiffuseS
     , m_diffuseSpecularMapGL3Shader(new QShaderProgram())
     , m_diffuseSpecularMapGL2ES2Shader(new QShaderProgram())
 {
-    m_diffuseTexture->setMagnificationFilter(QTexture::Linear);
-    m_diffuseTexture->setMinificationFilter(QTexture::LinearMipMapLinear);
+    m_diffuseTexture->setMagnificationFilter(QAbstractTextureProvider::Linear);
+    m_diffuseTexture->setMinificationFilter(QAbstractTextureProvider::LinearMipMapLinear);
     m_diffuseTexture->setWrapMode(QTextureWrapMode(QTextureWrapMode::Repeat));
     m_diffuseTexture->setGenerateMipMaps(true);
     m_diffuseTexture->setMaximumAnisotropy(16.0f);
 
-    m_specularTexture->setMagnificationFilter(QTexture::Linear);
-    m_specularTexture->setMinificationFilter(QTexture::LinearMipMapLinear);
+    m_specularTexture->setMagnificationFilter(QAbstractTextureProvider::Linear);
+    m_specularTexture->setMinificationFilter(QAbstractTextureProvider::LinearMipMapLinear);
     m_specularTexture->setWrapMode(QTextureWrapMode(QTextureWrapMode::Repeat));
     m_specularTexture->setGenerateMipMaps(true);
     m_specularTexture->setMaximumAnisotropy(16.0f);
@@ -196,10 +196,10 @@ QColor QDiffuseSpecularMapMaterial::ambient() const
     the wrap mode is repeat, the maximum anisotropy is set to 16.0
     and mipmapping is enabled.
  */
-QTexture *QDiffuseSpecularMapMaterial::diffuse() const
+QAbstractTextureProvider *QDiffuseSpecularMapMaterial::diffuse() const
 {
     Q_D(const QDiffuseSpecularMapMaterial);
-    return d->m_diffuseParameter->value().value<QTexture *>();
+    return d->m_diffuseParameter->value().value<QAbstractTextureProvider *>();
 }
 
 /*!
@@ -210,10 +210,10 @@ QTexture *QDiffuseSpecularMapMaterial::diffuse() const
     the wrap mode is repeat, the maximum anisotropy is set to 16.0
     and mipmapping is enabled.
  */
-QTexture *QDiffuseSpecularMapMaterial::specular() const
+QAbstractTextureProvider *QDiffuseSpecularMapMaterial::specular() const
 {
     Q_D(const QDiffuseSpecularMapMaterial);
-    return d->m_specularParameter->value().value<QTexture *>();
+    return d->m_specularParameter->value().value<QAbstractTextureProvider *>();
 }
 
 /*!
@@ -250,7 +250,7 @@ void QDiffuseSpecularMapMaterial::setAmbient(const QColor &ambient)
     \fn Qt3D::QDiffuseSpecularMapMaterial::setDiffuse(QTexture *diffuse)
     Sets the current diffuse map to \a diffuse.
  */
-void QDiffuseSpecularMapMaterial::setDiffuse(QTexture *diffuse)
+void QDiffuseSpecularMapMaterial::setDiffuse(QAbstractTextureProvider *diffuse)
 {
     Q_D(QDiffuseSpecularMapMaterial);
     d->m_diffuseParameter->setValue(QVariant::fromValue(diffuse));
@@ -260,7 +260,7 @@ void QDiffuseSpecularMapMaterial::setDiffuse(QTexture *diffuse)
     \fn Qt3D::QDiffuseSpecularMapMaterial::setSpecular(QTexture *specular)
     Sets the current specular map to \a specular.
  */
-void QDiffuseSpecularMapMaterial::setSpecular(QTexture *specular)
+void QDiffuseSpecularMapMaterial::setSpecular(QAbstractTextureProvider *specular)
 {
     Q_D(QDiffuseSpecularMapMaterial);
     d->m_specularParameter->setValue(QVariant::fromValue(specular));
diff --git a/src/render/defaults/qdiffusespecularmapmaterial.h b/src/render/defaults/qdiffusespecularmapmaterial.h
index bcaa5b37e..06c184ce0 100644
--- a/src/render/defaults/qdiffusespecularmapmaterial.h
+++ b/src/render/defaults/qdiffusespecularmapmaterial.h
@@ -49,7 +49,7 @@ QT_BEGIN_NAMESPACE
 
 namespace Qt3D {
 
-class QTexture;
+class QAbstractTextureProvider;
 class QDiffuseSpecularMapMaterialPrivate;
 
 class QT3DRENDERERSHARED_EXPORT QDiffuseSpecularMapMaterial : public QMaterial
@@ -57,8 +57,8 @@ class QT3DRENDERERSHARED_EXPORT QDiffuseSpecularMapMaterial : public QMaterial
     Q_OBJECT
     Q_PROPERTY(QColor ambient READ ambient WRITE setAmbient NOTIFY ambientChanged)
     Q_PROPERTY(float shininess READ shininess WRITE setShininess NOTIFY shininessChanged)
-    Q_PROPERTY(QTexture *specular READ specular WRITE setSpecular NOTIFY specularChanged)
-    Q_PROPERTY(QTexture *diffuse READ diffuse WRITE setDiffuse NOTIFY diffuseChanged)
+    Q_PROPERTY(QAbstractTextureProvider *specular READ specular WRITE setSpecular NOTIFY specularChanged)
+    Q_PROPERTY(QAbstractTextureProvider *diffuse READ diffuse WRITE setDiffuse NOTIFY diffuseChanged)
     Q_PROPERTY(float textureScale READ textureScale WRITE setTextureScale NOTIFY textureScaleChanged)
 
 public:
@@ -66,14 +66,14 @@ public:
     ~QDiffuseSpecularMapMaterial();
 
     QColor ambient() const;
-    QTexture *diffuse() const;
-    QTexture *specular() const;
+    QAbstractTextureProvider *diffuse() const;
+    QAbstractTextureProvider *specular() const;
     float shininess() const;
     float textureScale() const;
 
     void setAmbient(const QColor &ambient);
-    void setDiffuse(QTexture *diffuse);
-    void setSpecular(QTexture *specular);
+    void setDiffuse(QAbstractTextureProvider *diffuse);
+    void setSpecular(QAbstractTextureProvider *specular);
     void setShininess(float shininess);
     void setTextureScale(float textureScale);
 
diff --git a/src/render/defaults/qdiffusespecularmapmaterial_p.h b/src/render/defaults/qdiffusespecularmapmaterial_p.h
index 8dc642443..4636d4cdd 100644
--- a/src/render/defaults/qdiffusespecularmapmaterial_p.h
+++ b/src/render/defaults/qdiffusespecularmapmaterial_p.h
@@ -49,7 +49,7 @@ QT_BEGIN_NAMESPACE
 namespace Qt3D {
 
 class QEffect;
-class QTexture;
+class QAbstractTextureProvider;
 class QTechnique;
 class QParameter;
 class QShaderProgram;
@@ -66,8 +66,8 @@ public:
     void init();
 
     QEffect *m_diffuseSpecularMapEffect;
-    QTexture *m_diffuseTexture;
-    QTexture *m_specularTexture;
+    QAbstractTextureProvider *m_diffuseTexture;
+    QAbstractTextureProvider *m_specularTexture;
     QParameter *m_ambientParameter;
     QParameter *m_diffuseParameter;
     QParameter *m_specularParameter;
diff --git a/src/render/defaults/qnormaldiffusemapmaterial.cpp b/src/render/defaults/qnormaldiffusemapmaterial.cpp
index 896de08b7..cead0c51a 100644
--- a/src/render/defaults/qnormaldiffusemapmaterial.cpp
+++ b/src/render/defaults/qnormaldiffusemapmaterial.cpp
@@ -61,8 +61,8 @@ namespace Qt3D {
 QNormalDiffuseMapMaterialPrivate::QNormalDiffuseMapMaterialPrivate(QNormalDiffuseMapMaterial *qq)
     : QMaterialPrivate(qq)
     , m_normalDiffuseEffect(new QEffect())
-    , m_diffuseTexture(new QTexture(QTexture::Target2D))
-    , m_normalTexture(new QTexture(QTexture::Target2D))
+    , m_diffuseTexture(new QAbstractTextureProvider(QAbstractTextureProvider::Target2D))
+    , m_normalTexture(new QAbstractTextureProvider(QAbstractTextureProvider::Target2D))
     , m_ambientParameter(new QParameter(QStringLiteral("ka"), QColor::fromRgbF(0.1f, 0.1f, 0.1f, 1.0f)))
     , m_diffuseParameter(new QParameter(QStringLiteral("diffuseTexture"), m_diffuseTexture))
     , m_normalParameter(new QParameter(QStringLiteral("normalTexture"), m_normalTexture))
@@ -80,14 +80,14 @@ QNormalDiffuseMapMaterialPrivate::QNormalDiffuseMapMaterialPrivate(QNormalDiffus
     , m_normalDiffuseGL3Shader(new QShaderProgram())
     , m_normalDiffuseGL2ES2Shader(new QShaderProgram())
 {
-    m_diffuseTexture->setMagnificationFilter(QTexture::Linear);
-    m_diffuseTexture->setMinificationFilter(QTexture::LinearMipMapLinear);
+    m_diffuseTexture->setMagnificationFilter(QAbstractTextureProvider::Linear);
+    m_diffuseTexture->setMinificationFilter(QAbstractTextureProvider::LinearMipMapLinear);
     m_diffuseTexture->setWrapMode(QTextureWrapMode(QTextureWrapMode::Repeat));
     m_diffuseTexture->setGenerateMipMaps(true);
     m_diffuseTexture->setMaximumAnisotropy(16.0f);
 
-    m_normalTexture->setMagnificationFilter(QTexture::Linear);
-    m_normalTexture->setMinificationFilter(QTexture::Linear);
+    m_normalTexture->setMagnificationFilter(QAbstractTextureProvider::Linear);
+    m_normalTexture->setMinificationFilter(QAbstractTextureProvider::Linear);
     m_normalTexture->setWrapMode(QTextureWrapMode(QTextureWrapMode::Repeat));
     m_normalTexture->setMaximumAnisotropy(16.0f);
 }
@@ -221,10 +221,10 @@ QColor QNormalDiffuseMapMaterial::specular() const
     the wrap mode is repeat, the maximum anisotropy is set to 16.0
     and mipmapping is enabled.
  */
-QTexture *QNormalDiffuseMapMaterial::diffuse() const
+QAbstractTextureProvider *QNormalDiffuseMapMaterial::diffuse() const
 {
     Q_D(const QNormalDiffuseMapMaterial);
-    return d->m_diffuseParameter->value().value<QTexture *>();
+    return d->m_diffuseParameter->value().value<QAbstractTextureProvider *>();
 }
 
 /*!
@@ -234,10 +234,10 @@ QTexture *QNormalDiffuseMapMaterial::diffuse() const
     and magnification filters, the wrap mode is repeat and maximum anisotropy
     is set to 16.0.
  */
-QTexture *QNormalDiffuseMapMaterial::normal() const
+QAbstractTextureProvider *QNormalDiffuseMapMaterial::normal() const
 {
     Q_D(const QNormalDiffuseMapMaterial);
-    return d->m_normalParameter->value().value<QTexture *>();
+    return d->m_normalParameter->value().value<QAbstractTextureProvider *>();
 }
 
 /*!
@@ -284,7 +284,7 @@ void QNormalDiffuseMapMaterial::setSpecular(const QColor &specular)
     \fn Qt3D::QNormalDiffuseMapMaterial::setDiffuse(QTexture *diffuse)
     Sets the current diffuse map to \a diffuse.
  */
-void QNormalDiffuseMapMaterial::setDiffuse(QTexture *diffuse)
+void QNormalDiffuseMapMaterial::setDiffuse(QAbstractTextureProvider *diffuse)
 {
     Q_D(QNormalDiffuseMapMaterial);
     d->m_diffuseParameter->setValue(QVariant::fromValue(diffuse));
@@ -294,7 +294,7 @@ void QNormalDiffuseMapMaterial::setDiffuse(QTexture *diffuse)
     \fn Qt3D::QNormalDiffuseMapMaterial::setNormal(QTexture *normal)
     Sets the current normal map to \a normal.
  */
-void QNormalDiffuseMapMaterial::setNormal(QTexture *normal)
+void QNormalDiffuseMapMaterial::setNormal(QAbstractTextureProvider *normal)
 {
     Q_D(QNormalDiffuseMapMaterial);
     d->m_normalParameter->setValue(QVariant::fromValue(normal));
diff --git a/src/render/defaults/qnormaldiffusemapmaterial.h b/src/render/defaults/qnormaldiffusemapmaterial.h
index 34c1cf7c3..5c6320113 100644
--- a/src/render/defaults/qnormaldiffusemapmaterial.h
+++ b/src/render/defaults/qnormaldiffusemapmaterial.h
@@ -49,7 +49,7 @@ QT_BEGIN_NAMESPACE
 
 namespace Qt3D {
 
-class QTexture;
+class QAbstractTextureProvider;
 class QNormalDiffuseMapMaterialPrivate;
 
 class QT3DRENDERERSHARED_EXPORT QNormalDiffuseMapMaterial : public QMaterial
@@ -57,8 +57,8 @@ class QT3DRENDERERSHARED_EXPORT QNormalDiffuseMapMaterial : public QMaterial
     Q_OBJECT
     Q_PROPERTY(QColor ambient READ ambient WRITE setAmbient NOTIFY ambientChanged)
     Q_PROPERTY(QColor specular READ specular WRITE setSpecular NOTIFY specularChanged)
-    Q_PROPERTY(QTexture *diffuse READ diffuse WRITE setDiffuse NOTIFY diffuseChanged)
-    Q_PROPERTY(QTexture *normal READ normal WRITE setNormal NOTIFY normalChanged)
+    Q_PROPERTY(QAbstractTextureProvider *diffuse READ diffuse WRITE setDiffuse NOTIFY diffuseChanged)
+    Q_PROPERTY(QAbstractTextureProvider *normal READ normal WRITE setNormal NOTIFY normalChanged)
     Q_PROPERTY(float shininess READ shininess WRITE setShininess NOTIFY shininessChanged)
     Q_PROPERTY(float textureScale READ textureScale WRITE setTextureScale NOTIFY textureScaleChanged)
 
@@ -68,15 +68,15 @@ public:
 
     QColor ambient() const;
     QColor specular() const;
-    QTexture *diffuse() const;
-    QTexture *normal() const;
+    QAbstractTextureProvider *diffuse() const;
+    QAbstractTextureProvider *normal() const;
     float shininess() const;
     float textureScale() const;
 
     void setAmbient(const QColor &ambient);
     void setSpecular(const QColor &specular);
-    void setDiffuse(QTexture *diffuse);
-    void setNormal(QTexture *normal);
+    void setDiffuse(QAbstractTextureProvider *diffuse);
+    void setNormal(QAbstractTextureProvider *normal);
     void setShininess(float shininess);
     void setTextureScale(float textureScale);
 
diff --git a/src/render/defaults/qnormaldiffusemapmaterial_p.h b/src/render/defaults/qnormaldiffusemapmaterial_p.h
index eaa9ff496..7b4e3d90d 100644
--- a/src/render/defaults/qnormaldiffusemapmaterial_p.h
+++ b/src/render/defaults/qnormaldiffusemapmaterial_p.h
@@ -49,7 +49,7 @@ QT_BEGIN_NAMESPACE
 namespace Qt3D {
 
 class QEffect;
-class QTexture;
+class QAbstractTextureProvider;
 class QTechnique;
 class QParameter;
 class QShaderProgram;
@@ -66,8 +66,8 @@ public:
     virtual void init();
 
     QEffect *m_normalDiffuseEffect;
-    QTexture *m_diffuseTexture;
-    QTexture *m_normalTexture;
+    QAbstractTextureProvider *m_diffuseTexture;
+    QAbstractTextureProvider *m_normalTexture;
     QParameter *m_ambientParameter;
     QParameter *m_diffuseParameter;
     QParameter *m_normalParameter;
diff --git a/src/render/defaults/qnormaldiffusespecularmapmaterial.cpp b/src/render/defaults/qnormaldiffusespecularmapmaterial.cpp
index 0b21a4bb7..fb9d2fa97 100644
--- a/src/render/defaults/qnormaldiffusespecularmapmaterial.cpp
+++ b/src/render/defaults/qnormaldiffusespecularmapmaterial.cpp
@@ -60,9 +60,9 @@ namespace Qt3D {
 QNormalDiffuseSpecularMapMaterialPrivate::QNormalDiffuseSpecularMapMaterialPrivate(QNormalDiffuseSpecularMapMaterial *qq)
     : QMaterialPrivate(qq)
     , m_normalDiffuseSpecularEffect(new QEffect())
-    , m_diffuseTexture(new QTexture(QTexture::Target2D))
-    , m_normalTexture(new QTexture(QTexture::Target2D))
-    , m_specularTexture(new QTexture(QTexture::Target2D))
+    , m_diffuseTexture(new QAbstractTextureProvider(QAbstractTextureProvider::Target2D))
+    , m_normalTexture(new QAbstractTextureProvider(QAbstractTextureProvider::Target2D))
+    , m_specularTexture(new QAbstractTextureProvider(QAbstractTextureProvider::Target2D))
     , m_ambientParameter(new QParameter(QStringLiteral("ka"), QColor::fromRgbF(0.05f, 0.05f, 0.05f, 1.0f)))
     , m_diffuseParameter(new QParameter(QStringLiteral("diffuseTexture"), m_diffuseTexture))
     , m_normalParameter(new QParameter(QStringLiteral("normalTexture"), m_normalTexture))
@@ -80,19 +80,19 @@ QNormalDiffuseSpecularMapMaterialPrivate::QNormalDiffuseSpecularMapMaterialPriva
     , m_normalDiffuseSpecularGL3Shader(new QShaderProgram())
     , m_normalDiffuseSpecularGL2ES2Shader(new QShaderProgram())
 {
-    m_diffuseTexture->setMagnificationFilter(QTexture::Linear);
-    m_diffuseTexture->setMinificationFilter(QTexture::LinearMipMapLinear);
+    m_diffuseTexture->setMagnificationFilter(QAbstractTextureProvider::Linear);
+    m_diffuseTexture->setMinificationFilter(QAbstractTextureProvider::LinearMipMapLinear);
     m_diffuseTexture->setWrapMode(QTextureWrapMode(QTextureWrapMode::Repeat));
     m_diffuseTexture->setGenerateMipMaps(true);
     m_diffuseTexture->setMaximumAnisotropy(16.0f);
 
-    m_normalTexture->setMagnificationFilter(QTexture::Linear);
-    m_normalTexture->setMinificationFilter(QTexture::Linear);
+    m_normalTexture->setMagnificationFilter(QAbstractTextureProvider::Linear);
+    m_normalTexture->setMinificationFilter(QAbstractTextureProvider::Linear);
     m_normalTexture->setWrapMode(QTextureWrapMode(QTextureWrapMode::Repeat));
     m_normalTexture->setMaximumAnisotropy(16.0f);
 
-    m_specularTexture->setMagnificationFilter(QTexture::Linear);
-    m_specularTexture->setMinificationFilter(QTexture::LinearMipMapLinear);
+    m_specularTexture->setMagnificationFilter(QAbstractTextureProvider::Linear);
+    m_specularTexture->setMinificationFilter(QAbstractTextureProvider::LinearMipMapLinear);
     m_specularTexture->setWrapMode(QTextureWrapMode(QTextureWrapMode::Repeat));
     m_specularTexture->setGenerateMipMaps(true);
     m_specularTexture->setMaximumAnisotropy(16.0f);
@@ -218,10 +218,10 @@ QColor QNormalDiffuseSpecularMapMaterial::ambient() const
     the wrap mode is repeat, the maximum anisotropy is set to 16.0
     and mipmapping is enabled.
  */
-QTexture *QNormalDiffuseSpecularMapMaterial::diffuse() const
+QAbstractTextureProvider *QNormalDiffuseSpecularMapMaterial::diffuse() const
 {
     Q_D(const QNormalDiffuseSpecularMapMaterial);
-    return d->m_diffuseParameter->value().value<QTexture *>();
+    return d->m_diffuseParameter->value().value<QAbstractTextureProvider *>();
 }
 
 /*!
@@ -231,10 +231,10 @@ QTexture *QNormalDiffuseSpecularMapMaterial::diffuse() const
     and magnification filters, the wrap mode is repeat and maximum anisotropy
     is set to 16.0.
  */
-QTexture *QNormalDiffuseSpecularMapMaterial::normal() const
+QAbstractTextureProvider *QNormalDiffuseSpecularMapMaterial::normal() const
 {
     Q_D(const QNormalDiffuseSpecularMapMaterial);
-    return d->m_normalParameter->value().value<QTexture *>();
+    return d->m_normalParameter->value().value<QAbstractTextureProvider *>();
 }
 
 /*!
@@ -245,10 +245,10 @@ QTexture *QNormalDiffuseSpecularMapMaterial::normal() const
     the wrap mode is repeat, the maximum anisotropy is set to 16.0
     and mipmapping is enabled.
  */
-QTexture *QNormalDiffuseSpecularMapMaterial::specular() const
+QAbstractTextureProvider *QNormalDiffuseSpecularMapMaterial::specular() const
 {
     Q_D(const QNormalDiffuseSpecularMapMaterial);
-    return d->m_specularParameter->value().value<QTexture *>();
+    return d->m_specularParameter->value().value<QAbstractTextureProvider *>();
 }
 
 /*!
@@ -285,7 +285,7 @@ void QNormalDiffuseSpecularMapMaterial::setAmbient(const QColor &ambient)
     \fn Qt3D::QNormalDiffuseSpecularMapMaterial::setDiffuse(QTexture *diffuse)
     Sets the current diffuse map to \a diffuse.
  */
-void QNormalDiffuseSpecularMapMaterial::setDiffuse(QTexture *diffuse)
+void QNormalDiffuseSpecularMapMaterial::setDiffuse(QAbstractTextureProvider *diffuse)
 {
     Q_D(QNormalDiffuseSpecularMapMaterial);
     d->m_diffuseParameter->setValue(QVariant::fromValue(diffuse));
@@ -295,7 +295,7 @@ void QNormalDiffuseSpecularMapMaterial::setDiffuse(QTexture *diffuse)
     \fn Qt3D::QNormalDiffuseSpecularMapMaterial::setNormal(QTexture *normal)
     Sets the current normal map to \a normal.
  */
-void QNormalDiffuseSpecularMapMaterial::setNormal(QTexture *normal)
+void QNormalDiffuseSpecularMapMaterial::setNormal(QAbstractTextureProvider *normal)
 {
     Q_D(QNormalDiffuseSpecularMapMaterial);
     d->m_normalParameter->setValue(QVariant::fromValue(normal));
@@ -305,7 +305,7 @@ void QNormalDiffuseSpecularMapMaterial::setNormal(QTexture *normal)
     \fn Qt3D::QNormalDiffuseSpecularMapMaterial::setSpecular(QTexture *specular)
     Sets the current specular map to \a specular.
  */
-void QNormalDiffuseSpecularMapMaterial::setSpecular(QTexture *specular)
+void QNormalDiffuseSpecularMapMaterial::setSpecular(QAbstractTextureProvider *specular)
 {
     Q_D(QNormalDiffuseSpecularMapMaterial);
     d->m_specularParameter->setValue(QVariant::fromValue(specular));
diff --git a/src/render/defaults/qnormaldiffusespecularmapmaterial.h b/src/render/defaults/qnormaldiffusespecularmapmaterial.h
index 1694fe290..8e0dab80c 100644
--- a/src/render/defaults/qnormaldiffusespecularmapmaterial.h
+++ b/src/render/defaults/qnormaldiffusespecularmapmaterial.h
@@ -55,9 +55,9 @@ class QT3DRENDERERSHARED_EXPORT QNormalDiffuseSpecularMapMaterial : public QMate
 {
     Q_OBJECT
     Q_PROPERTY(QColor ambient READ ambient WRITE setAmbient NOTIFY ambientChanged)
-    Q_PROPERTY(QTexture *diffuse READ diffuse WRITE setDiffuse NOTIFY diffuseChanged)
-    Q_PROPERTY(QTexture *normal READ normal WRITE setNormal NOTIFY normalChanged)
-    Q_PROPERTY(QTexture *specular READ specular WRITE setSpecular NOTIFY specularChanged)
+    Q_PROPERTY(QAbstractTextureProvider *diffuse READ diffuse WRITE setDiffuse NOTIFY diffuseChanged)
+    Q_PROPERTY(QAbstractTextureProvider *normal READ normal WRITE setNormal NOTIFY normalChanged)
+    Q_PROPERTY(QAbstractTextureProvider *specular READ specular WRITE setSpecular NOTIFY specularChanged)
     Q_PROPERTY(float shininess READ shininess WRITE setShininess NOTIFY shininessChanged)
     Q_PROPERTY(float textureScale READ textureScale WRITE setTextureScale NOTIFY textureScaleChanged)
 
@@ -66,16 +66,16 @@ public:
     ~QNormalDiffuseSpecularMapMaterial();
 
     QColor ambient() const;
-    QTexture *diffuse() const;
-    QTexture *normal() const;
-    QTexture *specular() const;
+    QAbstractTextureProvider *diffuse() const;
+    QAbstractTextureProvider *normal() const;
+    QAbstractTextureProvider *specular() const;
     float shininess() const;
     float textureScale() const;
 
     void setAmbient(const QColor &ambient);
-    void setDiffuse(QTexture *diffuse);
-    void setNormal(QTexture *normal);
-    void setSpecular(QTexture *specular);
+    void setDiffuse(QAbstractTextureProvider *diffuse);
+    void setNormal(QAbstractTextureProvider *normal);
+    void setSpecular(QAbstractTextureProvider *specular);
     void setShininess(float shininess);
     void setTextureScale(float textureScale);
 
diff --git a/src/render/defaults/qnormaldiffusespecularmapmaterial_p.h b/src/render/defaults/qnormaldiffusespecularmapmaterial_p.h
index 0aa2ec2d9..529875c31 100644
--- a/src/render/defaults/qnormaldiffusespecularmapmaterial_p.h
+++ b/src/render/defaults/qnormaldiffusespecularmapmaterial_p.h
@@ -49,7 +49,7 @@ QT_BEGIN_NAMESPACE
 namespace Qt3D {
 
 class QEffect;
-class QTexture;
+class QAbstractTextureProvider;
 class QTechnique;
 class QParameter;
 class QShaderProgram;
@@ -66,9 +66,9 @@ public:
     void init();
 
     QEffect *m_normalDiffuseSpecularEffect;
-    QTexture *m_diffuseTexture;
-    QTexture *m_normalTexture;
-    QTexture *m_specularTexture;
+    QAbstractTextureProvider *m_diffuseTexture;
+    QAbstractTextureProvider *m_normalTexture;
+    QAbstractTextureProvider *m_specularTexture;
     QParameter *m_ambientParameter;
     QParameter *m_diffuseParameter;
     QParameter *m_normalParameter;
diff --git a/src/render/frontend/qmaterial.cpp b/src/render/frontend/qmaterial.cpp
index 842d51b91..5556d9aed 100644
--- a/src/render/frontend/qmaterial.cpp
+++ b/src/render/frontend/qmaterial.cpp
@@ -185,7 +185,7 @@ TextureDict QMaterial::textureValues() const
 }
 
 // TO DO: Check if this is really needed
-void QMaterial::setTextureParameter(QString name, QTexture *tex)
+void QMaterial::setTextureParameter(QString name, QAbstractTextureProvider *tex)
 {
     Q_D(QMaterial);
     d->m_textures[name] = tex;
diff --git a/src/render/frontend/qmaterial.h b/src/render/frontend/qmaterial.h
index b65034b27..36a15d401 100644
--- a/src/render/frontend/qmaterial.h
+++ b/src/render/frontend/qmaterial.h
@@ -51,11 +51,11 @@ QT_BEGIN_NAMESPACE
 
 namespace Qt3D {
 
-class QTexture;
+class QAbstractTextureProvider;
 class QParameter;
 class QMaterialPrivate;
 class QEffect;
-typedef QMap<QString, QTexture*> TextureDict;
+typedef QMap<QString, QAbstractTextureProvider*> TextureDict;
 
 class QT3DRENDERERSHARED_EXPORT QMaterial : public QComponent
 {
@@ -74,7 +74,7 @@ public:
 
     TextureDict textureValues() const;
 
-    void setTextureParameter(QString name, QTexture* tex);
+    void setTextureParameter(QString name, QAbstractTextureProvider* tex);
 
 Q_SIGNALS:
     void effectChanged();
diff --git a/src/render/frontend/qparameter.cpp b/src/render/frontend/qparameter.cpp
index df20b2df1..99f3ee37d 100644
--- a/src/render/frontend/qparameter.cpp
+++ b/src/render/frontend/qparameter.cpp
@@ -86,7 +86,7 @@ QParameter::QParameter(const QString &name, const QVariant &value, QNode *parent
     setValue(value);
 }
 
-QParameter::QParameter(const QString &name, QTexture *texture, QNode *parent)
+QParameter::QParameter(const QString &name, QAbstractTextureProvider *texture, QNode *parent)
     : QNode(*new QParameterPrivate(this), parent)
 {
     Q_D(QParameter);
diff --git a/src/render/frontend/qparameter.h b/src/render/frontend/qparameter.h
index b45248d1d..7f2b7b430 100644
--- a/src/render/frontend/qparameter.h
+++ b/src/render/frontend/qparameter.h
@@ -51,7 +51,7 @@ QT_BEGIN_NAMESPACE
 namespace Qt3D {
 
 class QParameterPrivate;
-class QTexture;
+class QAbstractTextureProvider;
 
 class QT3DRENDERERSHARED_EXPORT QParameter : public QNode
 {
@@ -62,7 +62,7 @@ class QT3DRENDERERSHARED_EXPORT QParameter : public QNode
 public:
     explicit QParameter(QNode *parent = 0);
     QParameter(const QString& name, const QVariant& value, QNode* parent = 0);
-    QParameter(const QString &name, QTexture *texture, QNode *parent = 0);
+    QParameter(const QString &name, QAbstractTextureProvider *texture, QNode *parent = 0);
 
     void setName(const QString &name);
     QString name() const;
diff --git a/src/render/frontend/qrenderattachment.cpp b/src/render/frontend/qrenderattachment.cpp
index 1e3898e7b..8940069ca 100644
--- a/src/render/frontend/qrenderattachment.cpp
+++ b/src/render/frontend/qrenderattachment.cpp
@@ -62,7 +62,7 @@ void QRenderAttachment::copy(const QNode *ref)
     QNode::copy(ref);
     const QRenderAttachment *rA = static_cast<const QRenderAttachment*>(ref);
     d_func()->m_type = rA->d_func()->m_type;
-    setTexture(qobject_cast<QTexture *>(QNode::clone(rA->d_func()->m_texture)));
+    setTexture(qobject_cast<QAbstractTextureProvider *>(QNode::clone(rA->d_func()->m_texture)));
 }
 
 QRenderAttachment::QRenderAttachment(QNode *parent)
@@ -90,7 +90,7 @@ QRenderAttachment::RenderAttachmentType QRenderAttachment::type() const
     return d->m_type;
 }
 
-void QRenderAttachment::setTexture(QTexture *texture)
+void QRenderAttachment::setTexture(QAbstractTextureProvider *texture)
 {
     Q_D(QRenderAttachment);
     if (texture != d->m_texture) {
@@ -103,7 +103,7 @@ void QRenderAttachment::setTexture(QTexture *texture)
     }
 }
 
-QTexture *QRenderAttachment::texture() const
+QAbstractTextureProvider *QRenderAttachment::texture() const
 {
     Q_D(const QRenderAttachment);
     return d->m_texture;
diff --git a/src/render/frontend/qrenderattachment.h b/src/render/frontend/qrenderattachment.h
index 52688e3c9..e569d0f9c 100644
--- a/src/render/frontend/qrenderattachment.h
+++ b/src/render/frontend/qrenderattachment.h
@@ -49,7 +49,7 @@ QT_BEGIN_NAMESPACE
 
 namespace Qt3D {
 
-class QTexture;
+class QAbstractTextureProvider;
 class QRenderAttachmentPrivate;
 
 class QT3DRENDERERSHARED_EXPORT QRenderAttachment : public QNode
@@ -58,7 +58,7 @@ class QT3DRENDERERSHARED_EXPORT QRenderAttachment : public QNode
     Q_ENUMS(RenderAttachmentType)
     Q_ENUMS(CubeMapFace)
     Q_PROPERTY(RenderAttachmentType type READ type WRITE setType NOTIFY typeChanged)
-    Q_PROPERTY(Qt3D::QTexture *texture READ texture WRITE setTexture NOTIFY textureChanged)
+    Q_PROPERTY(Qt3D::QAbstractTextureProvider *texture READ texture WRITE setTexture NOTIFY textureChanged)
     Q_PROPERTY(int mipLevel READ mipLevel WRITE setMipLevel NOTIFY mipLevelChanged)
     Q_PROPERTY(int layer READ layer WRITE setLayer NOTIFY layerChanged)
     Q_PROPERTY(CubeMapFace face READ face WRITE setFace NOTIFY faceChanged)
@@ -101,8 +101,8 @@ public:
     void setType(RenderAttachmentType type);
     RenderAttachmentType type() const;
 
-    void setTexture(QTexture *texture);
-    QTexture *texture() const;
+    void setTexture(QAbstractTextureProvider *texture);
+    QAbstractTextureProvider *texture() const;
 
     void setMipLevel(int level);
     int mipLevel() const;
diff --git a/src/render/frontend/qrenderattachment_p.h b/src/render/frontend/qrenderattachment_p.h
index 4e386ba8d..3e6760d2c 100644
--- a/src/render/frontend/qrenderattachment_p.h
+++ b/src/render/frontend/qrenderattachment_p.h
@@ -49,7 +49,7 @@ QT_BEGIN_NAMESPACE
 
 namespace Qt3D {
 
-class QTexture;
+class QAbstractTextureProvider;
 
 class QRenderAttachmentPrivate : public QNodePrivate
 {
@@ -58,7 +58,7 @@ public:
 
     Q_DECLARE_PUBLIC(QRenderAttachment)
 
-    QTexture *m_texture;
+    QAbstractTextureProvider *m_texture;
     QRenderAttachment::RenderAttachmentType m_type;
     int m_mipLevel;
     int m_layer;
diff --git a/src/render/frontend/qtexture.cpp b/src/render/frontend/qtexture.cpp
index 5a107504f..b28ad7c3b 100644
--- a/src/render/frontend/qtexture.cpp
+++ b/src/render/frontend/qtexture.cpp
@@ -52,47 +52,47 @@ QT_BEGIN_NAMESPACE
 
 namespace Qt3D {
 
-class QTexturePrivate : public QNodePrivate
+class QAbstractTextureProviderPrivate : public QNodePrivate
 {
 public :
-    QTexturePrivate(QTexture *qq)
+    QAbstractTextureProviderPrivate(QAbstractTextureProvider *qq)
         : QNodePrivate(qq)
-        , m_target(QTexture::Target2D)
-        , m_format(QTexture::RGBA8U)
+        , m_target(QAbstractTextureProvider::Target2D)
+        , m_format(QAbstractTextureProvider::RGBA8U)
         , m_width(1)
         , m_height(1)
         , m_depth(1)
         , m_autoMipMap(false)
-        , m_minFilter(QTexture::Nearest)
-        , m_magFilter(QTexture::Nearest)
-        , m_status(QTexture::Loading)
+        , m_minFilter(QAbstractTextureProvider::Nearest)
+        , m_magFilter(QAbstractTextureProvider::Nearest)
+        , m_status(QAbstractTextureProvider::Loading)
         , m_maximumAnisotropy(1.0f)
-        , m_comparisonFunction(QTexture::CompareLessEqual)
-        , m_comparisonMode(QTexture::CompareNone)
+        , m_comparisonFunction(QAbstractTextureProvider::CompareLessEqual)
+        , m_comparisonMode(QAbstractTextureProvider::CompareNone)
     {}
 
-    Q_DECLARE_PUBLIC(QTexture)
+    Q_DECLARE_PUBLIC(QAbstractTextureProvider)
 
-    QTexture::Target m_target;
-    QTexture::TextureFormat m_format;
+    QAbstractTextureProvider::Target m_target;
+    QAbstractTextureProvider::TextureFormat m_format;
     int m_width, m_height, m_depth;
     bool m_autoMipMap;
 
     QList<TexImageDataPtr> m_data;
 
-    QTexture::Filter m_minFilter, m_magFilter;
+    QAbstractTextureProvider::Filter m_minFilter, m_magFilter;
     // FIXME, store per direction
     QTextureWrapMode m_wrapMode;
-    QTexture::Status m_status;
+    QAbstractTextureProvider::Status m_status;
     float m_maximumAnisotropy;
-    QTexture::ComparisonFunction m_comparisonFunction;
-    QTexture::ComparisonMode m_comparisonMode;
+    QAbstractTextureProvider::ComparisonFunction m_comparisonFunction;
+    QAbstractTextureProvider::ComparisonMode m_comparisonMode;
 };
 
-void QTexture::copy(const QNode *ref)
+void QAbstractTextureProvider::copy(const QNode *ref)
 {
     QNode::copy(ref);
-    const QTexture *t = static_cast<const QTexture*>(ref);
+    const QAbstractTextureProvider *t = static_cast<const QAbstractTextureProvider*>(ref);
     d_func()->m_target = t->d_func()->m_target;
     d_func()->m_width = t->d_func()->m_width;
     d_func()->m_height = t->d_func()->m_height;
@@ -110,25 +110,39 @@ void QTexture::copy(const QNode *ref)
     // TO DO: Copy TexImageDataPtr
 }
 
-QTexture::QTexture(QNode *parent)
-    : QNode(*new QTexturePrivate(this), parent)
+/*!
+    \class Qt3D::QAbstractTextureProvider
+    \since 5.5
+    \brief Qt3D::QAbstractTextureProvider is a base class to be used to provide textures.
+
+    Qt3D::QAbstractTextureProvider shouldn't be used directly but rather
+    through one of its subclasses. Each subclass implements a given texture
+    target (2D, 2DArray, 3D, CubeMap ...) Each subclass provides a set of
+    functors for each layer, cube map face and mipmap level. In turn the
+    backend uses those functor to properly fill a corresponding OpenGL texture
+    with data.
+ */
+
+
+QAbstractTextureProvider::QAbstractTextureProvider(QNode *parent)
+    : QNode(*new QAbstractTextureProviderPrivate(this), parent)
 {
 }
 
-QTexture::QTexture(Target target, QNode *parent)
-    : QNode(*new QTexturePrivate(this), parent)
+QAbstractTextureProvider::QAbstractTextureProvider(Target target, QNode *parent)
+    : QNode(*new QAbstractTextureProviderPrivate(this), parent)
 {
     d_func()->m_target = target;
 }
 
-QTexture::QTexture(QTexture::Target target, QTexture::TextureFormat format,
+QAbstractTextureProvider::QAbstractTextureProvider(QAbstractTextureProvider::Target target, QAbstractTextureProvider::TextureFormat format,
                    int width, int height, int depth, bool mipMaps,
-                   QTexture::Filter magnificationFilter, QTexture::Filter minificationFilter,
+                   QAbstractTextureProvider::Filter magnificationFilter, QAbstractTextureProvider::Filter minificationFilter,
                    float maximumAnisotropy,
-                   QTexture::ComparisonFunction comparisonFunction,
-                   QTexture::ComparisonMode comparisonMode,
+                   QAbstractTextureProvider::ComparisonFunction comparisonFunction,
+                   QAbstractTextureProvider::ComparisonMode comparisonMode,
                    QNode *parent)
-    : QNode(*new QTexturePrivate(this), parent)
+    : QNode(*new QAbstractTextureProviderPrivate(this), parent)
 {
     d_func()->m_target = target;
     d_func()->m_format = format;
@@ -143,106 +157,143 @@ QTexture::QTexture(QTexture::Target target, QTexture::TextureFormat format,
     d_func()->m_comparisonMode = comparisonMode;
 }
 
-QTexture::QTexture(QTexturePrivate &dd, QNode *parent)
+QAbstractTextureProvider::QAbstractTextureProvider(QAbstractTextureProviderPrivate &dd, QNode *parent)
     : QNode(dd, parent)
 {
 }
 
-QTexture::~QTexture()
+QAbstractTextureProvider::~QAbstractTextureProvider()
 {
 }
 
-void QTexture::setSize(int w, int h, int d)
+/*!
+    Sets the size of the texture provider to width \a, height \a h and depth \a d.
+ */
+void QAbstractTextureProvider::setSize(int w, int h, int d)
 {
    setWidth(w);
    setHeight(h);
    setDepth(d);
 }
 
-void QTexture::setWidth(int width)
+/*!
+    Sets the width of the texture provider to \a width.
+ */
+void QAbstractTextureProvider::setWidth(int width)
 {
-    Q_D(QTexture);
+    Q_D(QAbstractTextureProvider);
     if (d->m_width != width) {
         d->m_width = width;
         emit widthChanged();
     }
 }
 
-void QTexture::setHeight(int height)
+/*!
+    Sets the height of the texture provider to \a height.
+ */
+void QAbstractTextureProvider::setHeight(int height)
 {
-    Q_D(QTexture);
+    Q_D(QAbstractTextureProvider);
     if (d->m_height != height) {
         d->m_height = height;
         emit heightChanged();
     }
 }
 
-void QTexture::setDepth(int depth)
+/*!
+    Sets the depth of the texture provider to \a depth.
+ */
+void QAbstractTextureProvider::setDepth(int depth)
 {
-    Q_D(QTexture);
+    Q_D(QAbstractTextureProvider);
     if (d->m_depth != depth) {
         d->m_depth = depth;
         emit depthChanged();
     }
 }
 
-int QTexture::width() const
+/*!
+    \returns the width of the texture provider.
+ */
+int QAbstractTextureProvider::width() const
 {
-    Q_D(const QTexture);
+    Q_D(const QAbstractTextureProvider);
     return d->m_width;
 }
 
-int QTexture::height() const
+/*!
+    \returns the height of the texture provider.
+ */
+int QAbstractTextureProvider::height() const
 {
-    Q_D(const QTexture);
+    Q_D(const QAbstractTextureProvider);
     return d->m_height;
 }
 
-int QTexture::depth() const
+/*!
+    \returns the depth of the texture provider.
+ */
+int QAbstractTextureProvider::depth() const
 {
-    Q_D(const QTexture);
+    Q_D(const QAbstractTextureProvider);
     return d->m_depth;
 }
 
-void QTexture::setFormat(TextureFormat format)
+/*!
+    Sets the format of the texture provider to \a format.
+ */
+void QAbstractTextureProvider::setFormat(TextureFormat format)
 {
-    Q_D(QTexture);
+    Q_D(QAbstractTextureProvider);
     if (d->m_format != format) {
         d->m_format = format;
         emit formatChanged();
     }
 }
 
-QTexture::TextureFormat QTexture::format() const
+/*!
+    \returns the format of the texture provider.
+ */
+QAbstractTextureProvider::TextureFormat QAbstractTextureProvider::format() const
 {
-    Q_D(const QTexture);
+    Q_D(const QAbstractTextureProvider);
     return d->m_format;
 }
 
-void QTexture::setStatus(Status status)
+/*!
+    Sets the current status of the texture provider to \a status.
+ */
+void QAbstractTextureProvider::setStatus(Status status)
 {
-    Q_D(QTexture);
+    Q_D(QAbstractTextureProvider);
     if (status != d->m_status) {
         d->m_status = status;
         emit statusChanged();
     }
 }
 
-QTexture::Status QTexture::status() const
+/*!
+    \returns the current status of the texture provider.
+ */
+QAbstractTextureProvider::Status QAbstractTextureProvider::status() const
 {
-    Q_D(const QTexture);
+    Q_D(const QAbstractTextureProvider);
     return d->m_status;
 }
 
-QTexture::Target QTexture::target() const
+/*!
+    \returns the target format of the texture provider.
+    \note: The target format can only be set once.
+ */
+QAbstractTextureProvider::Target QAbstractTextureProvider::target() const
 {
-    Q_D(const QTexture);
+    Q_D(const QAbstractTextureProvider);
     return d->m_target;
 }
 
-bool QTexture::setFromQImage(QImage img, int layer)
+bool QAbstractTextureProvider::setFromQImage(QImage img, int layer)
 {
-    Q_D(QTexture);
+    Q_D(QAbstractTextureProvider);
     setSize(img.width(), img.height());
 
     if ((d->m_target != Target2D) &&
@@ -260,66 +311,87 @@ bool QTexture::setFromQImage(QImage img, int layer)
     return true;
 }
 
-void QTexture::addImageData(TexImageDataPtr imgData)
+void QAbstractTextureProvider::addImageData(TexImageDataPtr imgData)
 {
-    Q_D(QTexture);
+    Q_D(QAbstractTextureProvider);
     d->m_data.append(imgData);
 }
 
-QList<TexImageDataPtr> QTexture::imageData() const
+QList<TexImageDataPtr> QAbstractTextureProvider::imageData() const
 {
-    Q_D(const QTexture);
+    Q_D(const QAbstractTextureProvider);
     return d->m_data;
 }
 
-void QTexture::setGenerateMipMaps(bool gen)
+/*!
+    Sets whether the texture provider should auto generate mipmaps.
+ */
+void QAbstractTextureProvider::setGenerateMipMaps(bool gen)
 {
-    Q_D(QTexture);
+    Q_D(QAbstractTextureProvider);
     if (d->m_autoMipMap != gen) {
         d->m_autoMipMap = gen;
         emit generateMipMapsChanged();
     }
 }
 
-bool QTexture::generateMipMaps() const
+/*!
+    \returns whether texture provider auto generates mipmaps.
+ */
+bool QAbstractTextureProvider::generateMipMaps() const
 {
-    Q_D(const QTexture);
+    Q_D(const QAbstractTextureProvider);
     return d->m_autoMipMap;
 }
 
-void QTexture::setMinificationFilter(Filter f)
+/*!
+    Sets the minification filter of the texture provider to \a f.
+ */
+void QAbstractTextureProvider::setMinificationFilter(Filter f)
 {
-    Q_D(QTexture);
+    Q_D(QAbstractTextureProvider);
     if (d->m_minFilter != f) {
         d->m_minFilter = f;
         emit minificationFilterChanged();
     }
 }
 
-void QTexture::setMagnificationFilter(Filter f)
+/*!
+    Sets the magnification filter of the texture provider to \a f.
+ */
+void QAbstractTextureProvider::setMagnificationFilter(Filter f)
 {
-    Q_D(QTexture);
+    Q_D(QAbstractTextureProvider);
     if (d->m_magFilter != f) {
         d->m_magFilter = f;
         emit magnificationFilterChanged();
     }
 }
 
-QTexture::Filter QTexture::minificationFilter() const
+/*!
+    \returns the minification filter of the texture provider.
+ */
+QAbstractTextureProvider::Filter QAbstractTextureProvider::minificationFilter() const
 {
-    Q_D(const QTexture);
+    Q_D(const QAbstractTextureProvider);
     return d->m_minFilter;
 }
 
-QTexture::Filter QTexture::magnificationFilter() const
+/*!
+    \returns the magnification filter of the texture provider.
+ */
+QAbstractTextureProvider::Filter QAbstractTextureProvider::magnificationFilter() const
 {
-    Q_D(const QTexture);
+    Q_D(const QAbstractTextureProvider);
     return d->m_magFilter;
 }
 
-void QTexture::setWrapMode(const QTextureWrapMode &wrapMode)
+/*!
+    Sets the wrap mode of the texture provider to \a wrapMode.
+ */
+void QAbstractTextureProvider::setWrapMode(const QTextureWrapMode &wrapMode)
 {
-    Q_D(QTexture);
+    Q_D(QAbstractTextureProvider);
     if (d->m_wrapMode.x() != wrapMode.x()) {
         d->m_wrapMode.setX(wrapMode.x());
         QScenePropertyChangePtr e(new QScenePropertyChange(NodeUpdated, this));
@@ -343,54 +415,75 @@ void QTexture::setWrapMode(const QTextureWrapMode &wrapMode)
     }
 }
 
-QTextureWrapMode *QTexture::wrapMode()
+/*!
+    \returns the wrap mode of the texture provider.
+ */
+QTextureWrapMode *QAbstractTextureProvider::wrapMode()
 {
-    Q_D(QTexture);
+    Q_D(QAbstractTextureProvider);
     return &d->m_wrapMode;
 }
 
-void QTexture::setMaximumAnisotropy(float anisotropy)
+/*!
+    Sets the maximum anisotropy of the texture provider to \a anisotropy.
+ */
+void QAbstractTextureProvider::setMaximumAnisotropy(float anisotropy)
 {
-    Q_D(QTexture);
+    Q_D(QAbstractTextureProvider);
     if (!qFuzzyCompare(d->m_maximumAnisotropy, anisotropy)) {
         d->m_maximumAnisotropy = anisotropy;
         emit maximumAnisotropyChanged();
     }
 }
 
-float QTexture::maximumAnisotropy() const
+/*!
+    \returns the maximum anisotropy of the texture provider.
+ */
+float QAbstractTextureProvider::maximumAnisotropy() const
 {
-    Q_D(const QTexture);
+    Q_D(const QAbstractTextureProvider);
     return d->m_maximumAnisotropy;
 }
 
-void QTexture::setComparisonFunction(QTexture::ComparisonFunction function)
+/*!
+    Sets the comparison function of the texture provider to \a function.
+ */
+void QAbstractTextureProvider::setComparisonFunction(QAbstractTextureProvider::ComparisonFunction function)
 {
-    Q_D(QTexture);
+    Q_D(QAbstractTextureProvider);
     if (d->m_comparisonFunction != function) {
         d->m_comparisonFunction = function;
         emit comparisonFunctionChanged();
     }
 }
 
-QTexture::ComparisonFunction QTexture::comparisonFunction() const
+/*!
+    \returns the comparison function of the texture provider.
+ */
+QAbstractTextureProvider::ComparisonFunction QAbstractTextureProvider::comparisonFunction() const
 {
-    Q_D(const QTexture);
+    Q_D(const QAbstractTextureProvider);
     return d->m_comparisonFunction;
 }
 
-void QTexture::setComparisonMode(QTexture::ComparisonMode mode)
+/*!
+    Sets the comparison mode of the texture provider to \a mode.
+ */
+void QAbstractTextureProvider::setComparisonMode(QAbstractTextureProvider::ComparisonMode mode)
 {
-    Q_D(QTexture);
+    Q_D(QAbstractTextureProvider);
     if (d->m_comparisonMode != mode) {
         d->m_comparisonMode = mode;
         emit comparisonModeChanged();
     }
 }
 
-QTexture::ComparisonMode QTexture::comparisonMode() const
+/*!
+   \returns the comparison mode of the texture provider.
+ */
+QAbstractTextureProvider::ComparisonMode QAbstractTextureProvider::comparisonMode() const
 {
-    Q_D(const QTexture);
+    Q_D(const QAbstractTextureProvider);
     return d->m_comparisonMode;
 }
 
@@ -413,6 +506,14 @@ public:
     QTextureWrapMode::WrapMode m_z;
 };
 
+/*!
+    \class Qt3D::QTextureWrapMode
+    \since 5.5
+
+    \brief Qt3D::QTextureWrapMode defines the wrap mode a
+    Qt3D::QAbstractTextureProvider should apply to a texture.
+ */
+
 QTextureWrapMode::QTextureWrapMode(WrapMode wrapMode, QObject *parent)
     : QObject(*new QTextureWrapModePrivate(this), parent)
 {
@@ -421,6 +522,10 @@ QTextureWrapMode::QTextureWrapMode(WrapMode wrapMode, QObject *parent)
     d_func()->m_z = wrapMode;
 }
 
+/*!
+    Contrusts a new Qt3D::QTextureWrapMode instance with the wrap mode to apply to
+    each dimension \a x, \a y \a z of the texture and \a parent as parent.
+ */
 QTextureWrapMode::QTextureWrapMode(WrapMode x,WrapMode y, WrapMode z, QObject *parent)
     : QObject(*new QTextureWrapModePrivate(this), parent)
 {
@@ -429,6 +534,9 @@ QTextureWrapMode::QTextureWrapMode(WrapMode x,WrapMode y, WrapMode z, QObject *p
     d_func()->m_z = z;
 }
 
+/*!
+    Sets the wrap mode of the x dimension to \a x.
+ */
 void QTextureWrapMode::setX(WrapMode x)
 {
     Q_D(QTextureWrapMode);
@@ -438,12 +546,18 @@ void QTextureWrapMode::setX(WrapMode x)
     }
 }
 
+/*!
+    \returns the wrap mode of the x dimension.
+ */
 QTextureWrapMode::WrapMode QTextureWrapMode::x() const
 {
     Q_D(const QTextureWrapMode);
     return d->m_x;
 }
 
+/*!
+    Sets the wrap mode of the y dimension to \a y.
+ */
 void QTextureWrapMode::setY(WrapMode y)
 {
     Q_D(QTextureWrapMode);
@@ -453,12 +567,18 @@ void QTextureWrapMode::setY(WrapMode y)
     }
 }
 
+/*!
+    \returns the wrap mode of the y dimension.
+ */
 QTextureWrapMode::WrapMode QTextureWrapMode::y() const
 {
     Q_D(const QTextureWrapMode);
     return d->m_y;
 }
 
+/*!
+    Sets the wrap mode of the z dimension to \a z.
+ */
 void QTextureWrapMode::setZ(WrapMode z)
 {
     Q_D(QTextureWrapMode);
@@ -468,6 +588,9 @@ void QTextureWrapMode::setZ(WrapMode z)
     }
 }
 
+/*!
+    \returns the wrap mode of the y dimension.
+ */
 QTextureWrapMode::WrapMode QTextureWrapMode::z() const
 {
     Q_D(const QTextureWrapMode);
diff --git a/src/render/frontend/qtexture.h b/src/render/frontend/qtexture.h
index 8ab4879a3..738b20a0b 100644
--- a/src/render/frontend/qtexture.h
+++ b/src/render/frontend/qtexture.h
@@ -51,7 +51,7 @@ QT_BEGIN_NAMESPACE
 
 namespace Qt3D {
 
-class QTexturePrivate;
+class QAbstractTextureProviderPrivate;
 class QTextureWrapModePrivate;
 
 class QT3DRENDERERSHARED_EXPORT QTextureWrapMode: public QObject
@@ -91,7 +91,7 @@ private:
     Q_DECLARE_PRIVATE(QTextureWrapMode)
 };
 
-class QT3DRENDERERSHARED_EXPORT QTexture : public QNode
+class QT3DRENDERERSHARED_EXPORT QAbstractTextureProvider : public QNode
 {
     Q_OBJECT
     Q_ENUMS(Target)
@@ -286,14 +286,14 @@ public:
         CompareNone         = 0x0000    // GL_NONE
     };
 
-    explicit QTexture(Target target, QNode *parent = 0);
-    explicit QTexture(Target target, TextureFormat format, int width, int height = 1, int depth = 1,
+    explicit QAbstractTextureProvider(Target target, QNode *parent = 0);
+    explicit QAbstractTextureProvider(Target target, TextureFormat format, int width, int height = 1, int depth = 1,
                       bool mipMaps = false, Filter magnificationFilter = Nearest, Filter minificationFilter = Nearest,
                       float maximumAnisotropy = 1.0f,
                       ComparisonFunction comparisonFunction = CompareLessEqual,
                       ComparisonMode comparisonMode = CompareNone,
                       QNode *parent = 0);
-    ~QTexture();
+    ~QAbstractTextureProvider();
 
 
     Target target() const;
@@ -361,23 +361,23 @@ Q_SIGNALS:
     void comparisonModeChanged();
 
 protected:
-    explicit QTexture(QNode *parent = 0);
-    QTexture(QTexturePrivate &dd, QNode *parent = 0);
+    explicit QAbstractTextureProvider(QNode *parent = 0);
+    QAbstractTextureProvider(QAbstractTextureProviderPrivate &dd, QNode *parent = 0);
     void copy(const QNode *ref) Q_DECL_OVERRIDE;
     void setStatus(Status status);
 
 private:
-    Q_DECLARE_PRIVATE(QTexture)
-    QT3D_CLONEABLE(QTexture)
+    Q_DECLARE_PRIVATE(QAbstractTextureProvider)
+    QT3D_CLONEABLE(QAbstractTextureProvider)
 };
 
 } // namespace Qt3D
 
 QT_END_NAMESPACE
 
-Q_DECLARE_METATYPE(Qt3D::QTexture*)
+Q_DECLARE_METATYPE(Qt3D::QAbstractTextureProvider*)
 Q_DECLARE_METATYPE(Qt3D::QTextureWrapMode*)
-Q_DECLARE_METATYPE(Qt3D::QTexture::ComparisonFunction)
-Q_DECLARE_METATYPE(Qt3D::QTexture::ComparisonMode)
+Q_DECLARE_METATYPE(Qt3D::QAbstractTextureProvider::ComparisonFunction)
+Q_DECLARE_METATYPE(Qt3D::QAbstractTextureProvider::ComparisonMode)
 
 #endif // QT3D_QTEXTURE_H
diff --git a/src/render/io/gltfparser.cpp b/src/render/io/gltfparser.cpp
index 1792014a1..b135fc3b0 100644
--- a/src/render/io/gltfparser.cpp
+++ b/src/render/io/gltfparser.cpp
@@ -793,14 +793,14 @@ void GLTFParser::processJSONImage( QString id, QJsonObject jsonObj)
 void GLTFParser::processJSONTexture( QString id, QJsonObject jsonObj)
 {
     int target = jsonObj.value(KEY_TARGET).toInt();
-    QTexture* tex = new QTexture(static_cast<QTexture::Target>(target));
+    QAbstractTextureProvider* tex = new QAbstractTextureProvider(static_cast<QAbstractTextureProvider::Target>(target));
 
 
     // TODO: Choose suitable internal format - may vary on OpenGL context type
     //int pixelFormat = jsonObj.value(KEY_FORMAT).toInt();
     //int internalFormat = jsonObj.value(KEY_INTERNAL_FORMAT).toInt();
 
-    tex->setFormat(QTexture::RGBA8_UNorm /* static_cast<QOpenGLTexture::TextureFormat>(internalFormat)*/);
+    tex->setFormat(QAbstractTextureProvider::RGBA8_UNorm /* static_cast<QOpenGLTexture::TextureFormat>(internalFormat)*/);
 
     QString samplerId = jsonObj.value(KEY_SAMPLER).toString();
     QString source = jsonObj.value(KEY_SOURCE).toString();
@@ -820,8 +820,8 @@ void GLTFParser::processJSONTexture( QString id, QJsonObject jsonObj)
     QJsonObject sampler = samplersDict.value(samplerId).toObject();
 
     tex->setWrapMode(QTextureWrapMode(static_cast<QTextureWrapMode::WrapMode>(sampler.value(KEY_WRAP_S).toInt())));
-    tex->setMinificationFilter(static_cast<QTexture::Filter>(sampler.value(KEY_MIN_FILTER).toInt()));
-    tex->setMagnificationFilter(static_cast<QTexture::Filter>(sampler.value(KEY_MAG_FILTER).toInt()));
+    tex->setMinificationFilter(static_cast<QAbstractTextureProvider::Filter>(sampler.value(KEY_MIN_FILTER).toInt()));
+    tex->setMagnificationFilter(static_cast<QAbstractTextureProvider::Filter>(sampler.value(KEY_MAG_FILTER).toInt()));
 
     m_textures[id] = tex;
 }
diff --git a/src/render/io/gltfparser_p.h b/src/render/io/gltfparser_p.h
index 10d8bfab7..152ff1c58 100644
--- a/src/render/io/gltfparser_p.h
+++ b/src/render/io/gltfparser_p.h
@@ -66,7 +66,7 @@ class QShaderProgram;
 class QEffect;
 class QCamera;
 class QCameraLens;
-class QTexture;
+class QAbstractTextureProvider;
 
 class GLTFParser : public AbstractSceneParser
 {
@@ -146,7 +146,7 @@ private:
     // up our techniques
     QMap<QString, QEffect*> m_effectProxies;
 
-    QMap<QString, QTexture*> m_textures;
+    QMap<QString, QAbstractTextureProvider*> m_textures;
     QMap<QString, QImage> m_images;
 
     QFile* resolveLocalData(QString path);