QTexture refactoring

Target is now set in the ctor from C++. On the QML side, there's a QTexture
subclass for each target.

WrapMode on s, t, r for texture, accessible as a grouped property in QML.

Note: I left out the static fromImage as I didn't really understand their
purpose. Please let me know what I'm missing.

Change-Id: I16f75283ae459cbd8ab2d1ec53584b3022bc965b
Task-number: QTBUG-41537
Reviewed-by: Sean Harmer <sean.harmer@kdab.com>

9 files changed, 373 insertions, 76 deletions

diff --git a/src/plugins/sceneparsers/assimp/assimpparser.cpp b/src/plugins/sceneparsers/assimp/assimpparser.cpp
index 1afe1856f..ee2e6fd0c 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 *texture = new QTexture(QTexture::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 *tex = new QTexture(QTexture::Target2D);
                 QImage textureImage;
                 if (!textureImage.load(fullPath) || !textureImage.isNull()) {
                     tex->setFromQImage(textureImage);
diff --git a/src/quick3d/imports/render/qt3dquick3drenderplugin.cpp b/src/quick3d/imports/render/qt3dquick3drenderplugin.cpp
index ceeb6201b..f07f7c977 100644
--- a/src/quick3d/imports/render/qt3dquick3drenderplugin.cpp
+++ b/src/quick3d/imports/render/qt3dquick3drenderplugin.cpp
@@ -120,7 +120,19 @@ void Qt3DQuick3DRenderPlugin::registerTypes(const char *uri)
     qmlRegisterExtendedType<Qt3D::QMaterial, Qt3D::Render::Quick::Quick3DMaterial>(uri, 2, 0, "Material");
     qmlRegisterExtendedType<Qt3D::QRenderPass, Qt3D::Render::Quick::Quick3DRenderPass>(uri, 2, 0, "RenderPass");
     qmlRegisterType<Qt3D::QShaderProgram>(uri, 2, 0, "ShaderProgram");
-    qmlRegisterExtendedType<Qt3D::QTexture, Qt3D::Render::Quick::Quick3DTexture>(uri, 2, 0, "Texture");
+
+    // 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"));
+    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");
+    qmlRegisterType<Qt3D::Render::Quick::Quick3DTexture2DArray>(uri, 2, 0, "Texture2DArray");
+    qmlRegisterType<Qt3D::Render::Quick::Quick3DTexture3D>(uri, 2, 0, "Texture3D");
+    qmlRegisterType<Qt3D::Render::Quick::Quick3DTextureCubeMap>(uri, 2, 0, "TextureCubeMap");
+    qmlRegisterType<Qt3D::Render::Quick::Quick3DTextureCubeMapArray>(uri, 2, 0, "TextureCubeMapArray");
+    qmlRegisterType<Qt3D::Render::Quick::Quick3DTexture2DMultisample>(uri, 2, 0, "Texture2DMultisample");
+    qmlRegisterType<Qt3D::Render::Quick::Quick3DTexture2DMultisampleArray>(uri, 2, 0, "Texture2DMultisampleArray");
 
     // Meshes
     qmlRegisterUncreatableType<Qt3D::QAbstractMesh>(uri, 2, 0, "QAbstractMesh", QStringLiteral("QAbstractMesh is abstract"));
diff --git a/src/quick3d/quick3drenderer/items/quick3dtexture.cpp b/src/quick3d/quick3drenderer/items/quick3dtexture.cpp
index 2cbd338a9..c609fb884 100644
--- a/src/quick3d/quick3drenderer/items/quick3dtexture.cpp
+++ b/src/quick3d/quick3drenderer/items/quick3dtexture.cpp
@@ -50,20 +50,73 @@ namespace Render {
 
 namespace Quick {
 
+Quick3DTexture1D::Quick3DTexture1D(QNode *parent)
+    : QTexture(Target1D, parent)
+{
+}
+
+Quick3DTexture1DArray::Quick3DTexture1DArray(QNode *parent)
+    : QTexture(Target1DArray, parent)
+{
+}
+
+Quick3DTexture2D::Quick3DTexture2D(QNode *parent)
+    : QTexture(Target2D, parent)
+{
+}
+
+Quick3DTexture2DArray::Quick3DTexture2DArray(QNode *parent)
+    : QTexture(Target2DArray, parent)
+{
+}
+
+Quick3DTexture3D::Quick3DTexture3D(QNode *parent)
+    : QTexture(Target3D, parent)
+{
+}
+
+Quick3DTextureCubeMap::Quick3DTextureCubeMap(QNode *parent)
+    : QTexture(TargetCubeMap, parent)
+{
+}
+
+Quick3DTextureCubeMapArray::Quick3DTextureCubeMapArray(QNode *parent)
+    : QTexture(TargetCubeMapArray, parent)
+{
+}
+
+Quick3DTexture2DMultisample::Quick3DTexture2DMultisample(QNode *parent)
+    : QTexture(Target2DMultisample, parent)
+{
+}
+
+Quick3DTexture2DMultisampleArray::Quick3DTexture2DMultisampleArray(QNode *parent)
+    : QTexture(Target2DMultisampleArray, parent)
+{
+}
+
+Quick3DTextureRectangle::Quick3DTextureRectangle(QNode *parent)
+    : QTexture(TargetRectangle, parent)
+{
+}
+
+Quick3DTextureBuffer::Quick3DTextureBuffer(QNode *parent)
+    : QTexture(TargetBuffer, parent)
+{
+}
+
 // TO DO: This needs to be reworked to handle more than just 2D images
-Quick3DTexture::Quick3DTexture(QObject *parent)
+Quick3DTexture2DExtension::Quick3DTexture2DExtension(QObject *parent)
     : QObject(parent)
 {
-    parentTexture()->setTarget(QTexture::Target2D);
-    parentTexture()->setFormat(QTexture::RGBA8_UNorm);
 }
 
-QUrl Quick3DTexture::source() const
+QUrl Quick3DTexture2DExtension::source() const
 {
     return m_source;
 }
 
-void Quick3DTexture::setSource(QUrl arg)
+void Quick3DTexture2DExtension::setSource(QUrl arg)
 {
     if (m_source != arg) {
         m_source = arg;
@@ -88,17 +141,6 @@ void Quick3DTexture::setSource(QUrl arg)
     }
 }
 
-void Quick3DTexture::setRectangle(bool r)
-{
-    parentTexture()->setTarget(r ? QTexture::TargetRectangle :
-                                   QTexture::Target2D);
-}
-
-bool Quick3DTexture::isRectangle() const
-{
-    return (parentTexture()->target() == QTexture::TargetRectangle);
-}
-
 } // Quick
 
 } // Render
diff --git a/src/quick3d/quick3drenderer/items/quick3dtexture.h b/src/quick3d/quick3drenderer/items/quick3dtexture.h
index 1ab75f994..554cb44f5 100644
--- a/src/quick3d/quick3drenderer/items/quick3dtexture.h
+++ b/src/quick3d/quick3drenderer/items/quick3dtexture.h
@@ -56,24 +56,95 @@ namespace Render {
 
 namespace Quick {
 
-class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTexture :
-        public QObject
+class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTexture1D : public QTexture
+{
+    Q_OBJECT
+public:
+    explicit Quick3DTexture1D(QNode *parent = 0);
+};
+
+class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTexture1DArray : public QTexture
+{
+    Q_OBJECT
+public:
+    explicit Quick3DTexture1DArray(QNode *parent = 0);
+};
+
+class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTexture2D : public QTexture
+{
+    Q_OBJECT
+public:
+    explicit Quick3DTexture2D(QNode *parent = 0);
+};
+
+class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTexture2DArray : public QTexture
+{
+    Q_OBJECT
+public:
+    explicit Quick3DTexture2DArray(QNode *parent = 0);
+};
+
+class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTexture3D : public QTexture
+{
+    Q_OBJECT
+public:
+    explicit Quick3DTexture3D(QNode *parent = 0);
+};
+
+class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTextureCubeMap : public QTexture
+{
+    Q_OBJECT
+public:
+    explicit Quick3DTextureCubeMap(QNode *parent = 0);
+};
+
+class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTextureCubeMapArray : public QTexture
+{
+    Q_OBJECT
+public:
+    explicit Quick3DTextureCubeMapArray(QNode *parent = 0);
+};
+
+class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTexture2DMultisample : public QTexture
+{
+    Q_OBJECT
+public:
+    explicit Quick3DTexture2DMultisample(QNode *parent = 0);
+};
+
+class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTexture2DMultisampleArray : public QTexture
+{
+    Q_OBJECT
+public:
+    explicit Quick3DTexture2DMultisampleArray(QNode *parent = 0);
+};
+
+class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTextureRectangle : public QTexture
+{
+    Q_OBJECT
+public:
+    explicit Quick3DTextureRectangle(QNode *parent = 0);
+};
+
+class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTextureBuffer : public QTexture
+{
+    Q_OBJECT
+public:
+    explicit Quick3DTextureBuffer(QNode *parent = 0);
+};
+
+class QT3DQUICKRENDERERSHARED_EXPORT Quick3DTexture2DExtension : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(QUrl source READ source WRITE setSource NOTIFY sourceChanged)
-    Q_PROPERTY(bool rectangle READ isRectangle WRITE setRectangle NOTIFY isRectangleChanged)
 public:
-    explicit Quick3DTexture(QObject *parent = 0);
+    explicit Quick3DTexture2DExtension(QObject *parent = 0);
 
     QUrl source() const;
     void setSource(QUrl arg);
 
-    void setRectangle(bool r);
-    bool isRectangle() const;
-
 Q_SIGNALS:
     void sourceChanged();
-    void isRectangleChanged();
 
 private:
     QUrl m_source;
diff --git a/src/render/backend/rendertexture.cpp b/src/render/backend/rendertexture.cpp
index d2f33e19c..821e7c3fa 100644
--- a/src/render/backend/rendertexture.cpp
+++ b/src/render/backend/rendertexture.cpp
@@ -67,7 +67,9 @@ RenderTexture::RenderTexture()
     , m_format(QTexture::RGBA8U)
     , m_magnificationFilter(QTexture::Nearest)
     , m_minificationFilter(QTexture::Nearest)
-    , m_wrapMode(QTexture::ClampToEdge)
+    , m_wrapModeX(QTextureWrapMode::ClampToEdge)
+    , m_wrapModeY(QTextureWrapMode::ClampToEdge)
+    , m_wrapModeZ(QTextureWrapMode::ClampToEdge)
     , m_maximumAnisotropy(1.0f)
     , m_isDirty(false)
     , m_filtersAndWrapUpdated(false)
@@ -103,7 +105,9 @@ void RenderTexture::updateFromPeer(QNode *peer)
         m_format = texture->format();
         m_magnificationFilter = texture->magnificationFilter();
         m_minificationFilter = texture->minificationFilter();
-        m_wrapMode = texture->wrapMode();
+        m_wrapModeX = texture->wrapMode()->x();
+        m_wrapModeY = texture->wrapMode()->y();
+        m_wrapModeZ = texture->wrapMode()->z();
         m_maximumAnisotropy = texture->maximumAnisotropy();
         // See where it is best to handle source and loading
         Q_FOREACH (TexImageDataPtr imgData, texture->imageData())
@@ -224,7 +228,15 @@ void RenderTexture::setToGLTexture(TexImageDataPtr imgData)
 
 void RenderTexture::updateWrapAndFilters()
 {
-    m_gl->setWrapMode(static_cast<QOpenGLTexture::WrapMode>(m_wrapMode));
+    m_gl->setWrapMode(QOpenGLTexture::DirectionS, static_cast<QOpenGLTexture::WrapMode>(m_wrapModeX));
+    if (m_target != QTexture::Target1D &&
+            m_target != QTexture::Target1DArray &&
+            m_target != QTexture::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)
+        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));
     m_gl->setMaximumAnisotropy(m_maximumAnisotropy);
@@ -276,10 +288,18 @@ void RenderTexture::sceneChangeEvent(const QSceneChangePtr &e)
             QTexture::Filter oldMagFilter = m_magnificationFilter;
             m_magnificationFilter = static_cast<QTexture::Filter>(propertyChange->value().toInt());
             m_filtersAndWrapUpdated = (oldMagFilter != m_magnificationFilter);
-        } else if (propertyChange->propertyName() == QByteArrayLiteral("wrapMode")) {
-            QTexture::WrapMode oldWrapMode = m_wrapMode;
-            m_wrapMode = static_cast<QTexture::WrapMode>(propertyChange->value().toInt());
-            m_filtersAndWrapUpdated = (oldWrapMode != m_wrapMode);
+        } else if (propertyChange->propertyName() == QByteArrayLiteral("wrapModeX")) {
+            QTextureWrapMode::WrapMode oldWrapModeX = m_wrapModeX;
+            m_wrapModeX = static_cast<QTextureWrapMode::WrapMode>(propertyChange->value().toInt());
+            m_filtersAndWrapUpdated = (oldWrapModeX != m_wrapModeX);
+        } else if (propertyChange->propertyName() == QByteArrayLiteral("wrapModeX")) {
+            QTextureWrapMode::WrapMode oldWrapModeY = m_wrapModeY;
+            m_wrapModeY = static_cast<QTextureWrapMode::WrapMode>(propertyChange->value().toInt());
+            m_filtersAndWrapUpdated = (oldWrapModeY != m_wrapModeY);
+        } else if (propertyChange->propertyName() == QByteArrayLiteral("wrapModeX")) {
+            QTextureWrapMode::WrapMode oldWrapModeZ = m_wrapModeZ;
+            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());
diff --git a/src/render/backend/rendertexture_p.h b/src/render/backend/rendertexture_p.h
index c3d78044b..214ef6d1d 100644
--- a/src/render/backend/rendertexture_p.h
+++ b/src/render/backend/rendertexture_p.h
@@ -92,7 +92,9 @@ private:
     QTexture::TextureFormat m_format;
     QTexture::Filter m_magnificationFilter;
     QTexture::Filter m_minificationFilter;
-    QTexture::WrapMode m_wrapMode;
+    QTextureWrapMode::WrapMode m_wrapModeX;
+    QTextureWrapMode::WrapMode m_wrapModeY;
+    QTextureWrapMode::WrapMode m_wrapModeZ;
     float m_maximumAnisotropy;
     QList<TexImageDataPtr> m_imageData;
     bool m_isDirty;
diff --git a/src/render/frontend/qtexture.cpp b/src/render/frontend/qtexture.cpp
index 39a660acd..a977245cd 100644
--- a/src/render/frontend/qtexture.cpp
+++ b/src/render/frontend/qtexture.cpp
@@ -65,7 +65,6 @@ public :
         , m_autoMipMap(false)
         , m_minFilter(QTexture::Nearest)
         , m_magFilter(QTexture::Nearest)
-        , m_wrapMode(QTexture::ClampToEdge)
         , m_status(QTexture::Loading)
         , m_maximumAnisotropy(1.0f)
     {}
@@ -81,7 +80,7 @@ public :
 
     QTexture::Filter m_minFilter, m_magFilter;
     // FIXME, store per direction
-    QTexture::WrapMode m_wrapMode;
+    QTextureWrapMode m_wrapMode;
     QTexture::Status m_status;
     float m_maximumAnisotropy;
 };
@@ -95,7 +94,9 @@ void QTexture::copy(const QNode *ref)
     d_func()->m_height = t->d_func()->m_height;
     d_func()->m_depth = t->d_func()->m_depth;
     d_func()->m_format = t->d_func()->m_format;
-    d_func()->m_wrapMode = t->d_func()->m_wrapMode;
+    d_func()->m_wrapMode.setX(t->d_func()->m_wrapMode.x());
+    d_func()->m_wrapMode.setY(t->d_func()->m_wrapMode.y());
+    d_func()->m_wrapMode.setZ(t->d_func()->m_wrapMode.z());
     d_func()->m_minFilter = t->d_func()->m_minFilter;
     d_func()->m_magFilter = t->d_func()->m_magFilter;
     d_func()->m_autoMipMap = t->d_func()->m_autoMipMap;
@@ -107,23 +108,36 @@ QTexture::QTexture(QNode *parent)
 {
 }
 
-QTexture::QTexture(QTexturePrivate &dd, QNode *parent)
-    : QNode(dd, parent)
+QTexture::QTexture(Target target, QNode *parent)
+    : QNode(*new QTexturePrivate(this), parent)
 {
+    d_func()->m_target = target;
 }
 
-QTexture::~QTexture()
+QTexture::QTexture(QTexture::Target target, QTexture::TextureFormat format,
+                   int width, int height, int depth, bool mipMaps,
+                   QTexture::Filter magnificationFilter, QTexture::Filter minificationFilter,
+                   float maximumAnisotropy, QNode *parent)
+    : QNode(*new QTexturePrivate(this), parent)
 {
+    d_func()->m_target = target;
+    d_func()->m_format = format;
+    d_func()->m_width = width;
+    d_func()->m_height = height;
+    d_func()->m_depth = depth;
+    d_func()->m_autoMipMap = mipMaps;
+    d_func()->m_magFilter = magnificationFilter;
+    d_func()->m_minFilter = minificationFilter;
+    d_func()->m_maximumAnisotropy = maximumAnisotropy;
 }
 
+QTexture::QTexture(QTexturePrivate &dd, QNode *parent)
+    : QNode(dd, parent)
+{
+}
 
-void QTexture::setTarget(Target target)
+QTexture::~QTexture()
 {
-    Q_D(QTexture);
-    if (d->m_target != target) {
-        d->m_target = target;
-        emit targetChanged();
-    }
 }
 
 void QTexture::setSize(int w, int h, int d)
@@ -291,19 +305,36 @@ QTexture::Filter QTexture::magnificationFilter() const
     return d->m_magFilter;
 }
 
-void QTexture::setWrapMode(WrapMode wrapMode)
+void QTexture::setWrapMode(const QTextureWrapMode &wrapMode)
 {
     Q_D(QTexture);
-    if (d->m_wrapMode != wrapMode) {
-        d->m_wrapMode = wrapMode;
-        emit wrapModeChanged();
+    if (d->m_wrapMode.x() != wrapMode.x()) {
+        d->m_wrapMode.setX(wrapMode.x());
+        QScenePropertyChangePtr e(new QScenePropertyChange(NodeUpdated, this));
+        e->setPropertyName(QByteArrayLiteral("wrapModeX"));
+        e->setValue(static_cast<int>(d->m_wrapMode.x()));
+        d->notifyObservers(e);
+    }
+    if (d->m_wrapMode.y() != wrapMode.y()) {
+        d->m_wrapMode.setY(wrapMode.y());
+        QScenePropertyChangePtr e(new QScenePropertyChange(NodeUpdated, this));
+        e->setPropertyName(QByteArrayLiteral("wrapModeY"));
+        e->setValue(static_cast<int>(d->m_wrapMode.y()));
+        d->notifyObservers(e);
+    }
+    if (d->m_wrapMode.z() != wrapMode.z()) {
+        d->m_wrapMode.setZ(wrapMode.z());
+        QScenePropertyChangePtr e(new QScenePropertyChange(NodeUpdated, this));
+        e->setPropertyName(QByteArrayLiteral("wrapModeZ"));
+        e->setValue(static_cast<int>(d->m_wrapMode.z()));
+        d->notifyObservers(e);
     }
 }
 
-QTexture::WrapMode QTexture::wrapMode() const
+QTextureWrapMode *QTexture::wrapMode()
 {
-    Q_D(const QTexture);
-    return d->m_wrapMode;
+    Q_D(QTexture);
+    return &d->m_wrapMode;
 }
 
 void QTexture::setMaximumAnisotropy(float anisotropy)
@@ -321,6 +352,86 @@ float QTexture::maximumAnisotropy() const
     return d->m_maximumAnisotropy;
 }
 
+class QTextureWrapModePrivate : public QObjectPrivate
+{
+public:
+    QTextureWrapModePrivate(QTextureWrapMode *qq)
+        : QObjectPrivate()
+        , q_ptr(qq)
+        , m_x(QTextureWrapMode::ClampToEdge)
+        , m_y(QTextureWrapMode::ClampToEdge)
+        , m_z(QTextureWrapMode::ClampToEdge)
+    {
+    }
+
+    Q_DECLARE_PUBLIC(QTextureWrapMode)
+    QTextureWrapMode *q_ptr;
+    QTextureWrapMode::WrapMode m_x;
+    QTextureWrapMode::WrapMode m_y;
+    QTextureWrapMode::WrapMode m_z;
+};
+
+QTextureWrapMode::QTextureWrapMode(WrapMode wrapMode, QObject *parent)
+    : QObject(*new QTextureWrapModePrivate(this), parent)
+{
+    d_func()->m_x = wrapMode;
+    d_func()->m_y = wrapMode;
+    d_func()->m_z = wrapMode;
+}
+
+QTextureWrapMode::QTextureWrapMode(WrapMode x,WrapMode y, WrapMode z, QObject *parent)
+    : QObject(*new QTextureWrapModePrivate(this), parent)
+{
+    d_func()->m_x = x;
+    d_func()->m_y = y;
+    d_func()->m_z = z;
+}
+
+void QTextureWrapMode::setX(WrapMode x)
+{
+    Q_D(QTextureWrapMode);
+    if (d->m_x != x) {
+        d->m_x = x;
+        emit xChanged();
+    }
+}
+
+QTextureWrapMode::WrapMode QTextureWrapMode::x() const
+{
+    Q_D(const QTextureWrapMode);
+    return d->m_x;
+}
+
+void QTextureWrapMode::setY(WrapMode y)
+{
+    Q_D(QTextureWrapMode);
+    if (d->m_y != y) {
+        d->m_y = y;
+        emit yChanged();
+    }
+}
+
+QTextureWrapMode::WrapMode QTextureWrapMode::y() const
+{
+    Q_D(const QTextureWrapMode);
+    return d->m_y;
+}
+
+void QTextureWrapMode::setZ(WrapMode z)
+{
+    Q_D(QTextureWrapMode);
+    if (d->m_z != z) {
+        d->m_z = z;
+        emit zChanged();
+    }
+}
+
+QTextureWrapMode::WrapMode QTextureWrapMode::z() const
+{
+    Q_D(const QTextureWrapMode);
+    return d->m_z;
+}
+
 } // namespace Qt3D
 
 QT_END_NAMESPACE
diff --git a/src/render/frontend/qtexture.h b/src/render/frontend/qtexture.h
index e04c4136e..532454a71 100644
--- a/src/render/frontend/qtexture.h
+++ b/src/render/frontend/qtexture.h
@@ -52,6 +52,44 @@ QT_BEGIN_NAMESPACE
 namespace Qt3D {
 
 class QTexturePrivate;
+class QTextureWrapModePrivate;
+
+class QT3DRENDERERSHARED_EXPORT QTextureWrapMode: public QObject
+{
+    Q_OBJECT
+    Q_ENUMS(WrapMode)
+    Q_PROPERTY(WrapMode x READ x WRITE setX NOTIFY xChanged)
+    Q_PROPERTY(WrapMode y READ y WRITE setY NOTIFY yChanged)
+    Q_PROPERTY(WrapMode z READ z WRITE setZ NOTIFY zChanged)
+
+public:
+    enum WrapMode {
+        Repeat         = 0x2901, // GL_REPEAT
+        MirroredRepeat = 0x8370, // GL_MIRRORED_REPEAT
+        ClampToEdge    = 0x812F, // GL_CLAMP_TO_EDGE
+        ClampToBorder  = 0x812D  // GL_CLAMP_TO_BORDER
+    };
+
+    explicit QTextureWrapMode(WrapMode wrapMode = ClampToEdge, QObject *parent = 0);
+    explicit QTextureWrapMode(WrapMode x, WrapMode y, WrapMode z, QObject *parent = 0);
+
+    void setX(WrapMode x);
+    WrapMode x() const;
+
+    void setY(WrapMode y);
+    WrapMode y() const;
+
+    void setZ(WrapMode z);
+    WrapMode z() const;
+
+Q_SIGNALS:
+    void xChanged();
+    void yChanged();
+    void zChanged();
+
+private:
+    Q_DECLARE_PRIVATE(QTextureWrapMode)
+};
 
 class QT3DRENDERERSHARED_EXPORT QTexture : public QNode
 {
@@ -59,12 +97,11 @@ class QT3DRENDERERSHARED_EXPORT QTexture : public QNode
     Q_ENUMS(Target)
     Q_ENUMS(TextureFormat)
     Q_ENUMS(Filter)
-    Q_ENUMS(WrapMode)
     Q_ENUMS(Status)
-    Q_PROPERTY(Target target READ target WRITE setTarget NOTIFY targetChanged)
+    Q_PROPERTY(Target target READ target CONSTANT)
     Q_PROPERTY(TextureFormat format READ format WRITE setFormat NOTIFY formatChanged)
     Q_PROPERTY(bool generateMipMaps READ generateMipMaps WRITE setGenerateMipMaps NOTIFY generateMipMapsChanged)
-    Q_PROPERTY(WrapMode wrapMode READ wrapMode WRITE setWrapMode NOTIFY wrapModeChanged)
+    Q_PROPERTY(Qt3D::QTextureWrapMode *wrapMode READ wrapMode CONSTANT)
     Q_PROPERTY(Status status READ status NOTIFY statusChanged)
     Q_PROPERTY(int width READ width WRITE setWidth NOTIFY widthChanged)
     Q_PROPERTY(int height READ height WRITE setHeight NOTIFY heightChanged)
@@ -74,8 +111,6 @@ class QT3DRENDERERSHARED_EXPORT QTexture : public QNode
     Q_PROPERTY(float maximumAnisotropy READ maximumAnisotropy WRITE setMaximumAnisotropy NOTIFY maximumAnisotropyChanged)
 
 public:
-    explicit QTexture(QNode *parent = 0);
-    ~QTexture();
 
     enum Status {
         Loading = 0,
@@ -222,14 +257,22 @@ public:
         LinearMipMapLinear      = 0x2703    // GL_LINEAR_MIPMAP_LINEAR
     };
 
-    enum WrapMode {
-        Repeat         = 0x2901, // GL_REPEAT
-        MirroredRepeat = 0x8370, // GL_MIRRORED_REPEAT
-        ClampToEdge    = 0x812F, // GL_CLAMP_TO_EDGE
-        ClampToBorder  = 0x812D  // GL_CLAMP_TO_BORDER
+    enum CubeMapFace {
+        CubeMapPositiveX = 0x8515,  // GL_TEXTURE_CUBE_MAP_POSITIVE_X
+        CubeMapNegativeX = 0x8516,  // GL_TEXTURE_CUBE_MAP_NEGATIVE_X
+        CubeMapPositiveY = 0x8517,  // GL_TEXTURE_CUBE_MAP_POSITIVE_Y
+        CubeMapNegativeY = 0x8518,  // GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
+        CubeMapPositiveZ = 0x8519,  // GL_TEXTURE_CUBE_MAP_POSITIVE_Z
+        CubeMapNegativeZ = 0x851A   // GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
     };
 
-    void setTarget(Target target);
+    explicit QTexture(Target target, QNode *parent = 0);
+    explicit QTexture(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, QNode *parent = 0);
+    ~QTexture();
+
+
     Target target() const;
 
     void setFormat(TextureFormat format);
@@ -257,11 +300,10 @@ public:
     void setMagnificationFilter(Filter f);
 
     Filter minificationFilter() const;
-
     Filter magnificationFilter() const;
 
-    void setWrapMode(WrapMode wrapMode);
-    WrapMode wrapMode() const;
+    void setWrapMode(const QTextureWrapMode &wrapMode);
+    QTextureWrapMode *wrapMode();
 
     void setMaximumAnisotropy(float anisotropy);
     float maximumAnisotropy() const;
@@ -277,11 +319,9 @@ public:
     int depth() const;
 
 Q_SIGNALS:
-    void targetChanged();
     void formatChanged();
     void statusChanged();
     void generateMipMapsChanged();
-    void wrapModeChanged();
     void widthChanged();
     void heightChanged();
     void depthChanged();
@@ -290,6 +330,7 @@ Q_SIGNALS:
     void maximumAnisotropyChanged();
 
 protected:
+    explicit QTexture(QNode *parent = 0);
     QTexture(QTexturePrivate &dd, QNode *parent = 0);
     void copy(const QNode *ref) Q_DECL_OVERRIDE;
     void setStatus(Status status);
@@ -304,5 +345,6 @@ private:
 QT_END_NAMESPACE
 
 Q_DECLARE_METATYPE(Qt3D::QTexture*)
+Q_DECLARE_METATYPE(Qt3D::QTextureWrapMode*)
 
 #endif // QT3D_QTEXTURE_H
diff --git a/src/render/io/gltfparser.cpp b/src/render/io/gltfparser.cpp
index 649482412..a035f29f0 100644
--- a/src/render/io/gltfparser.cpp
+++ b/src/render/io/gltfparser.cpp
@@ -792,15 +792,14 @@ void GLTFParser::processJSONImage( QString id, QJsonObject jsonObj)
 
 void GLTFParser::processJSONTexture( QString id, QJsonObject jsonObj)
 {
-    QTexture* tex = new QTexture();
-
     int target = jsonObj.value(KEY_TARGET).toInt();
+    QTexture* tex = new QTexture(static_cast<QTexture::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->setTarget(static_cast<QTexture::Target>(target));
     tex->setFormat(QTexture::RGBA8_UNorm /* static_cast<QOpenGLTexture::TextureFormat>(internalFormat)*/);
 
     QString samplerId = jsonObj.value(KEY_SAMPLER).toString();
@@ -820,9 +819,7 @@ void GLTFParser::processJSONTexture( QString id, QJsonObject jsonObj)
 
     QJsonObject sampler = samplersDict.value(samplerId).toObject();
 
-    tex->setWrapMode(static_cast<QTexture::WrapMode>(sampler.value(KEY_WRAP_S).toInt()));
-    // tex->setWrapMode(sampler.value("wrapT").toInt());
-
+    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()));