Renamed *Texture::set*Data() to set*Image().

Better consistency with OpenGL naming.

src/AbstractImage.h

@@ -45,7 +45,7 @@ class MAGNUM_EXPORT AbstractImage {
          *
          * Note that some formats can be used only for framebuffer reading
          * (using Framebuffer::read()) and some only for texture data (using
-         * Texture::setData() and others).
+         * Texture::setImage() and others).
          */
 
         /**

src/AbstractTexture.cpp

@@ -248,35 +248,35 @@ void AbstractTexture::parameterImplementationDSA(GLenum parameter, const GLfloat
     glTextureParameterfvEXT(_id, _target, parameter, values);
 }
 
-void AbstractTexture::imageImplementationDefault(GLenum target, GLint mipLevel, InternalFormat internalFormat, const Math::Vector<1, GLsizei>& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data) {
+void AbstractTexture::imageImplementationDefault(GLenum target, GLint level, InternalFormat internalFormat, const Math::Vector<1, GLsizei>& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data) {
     bindInternal();
-    glTexImage1D(target, mipLevel, static_cast<GLint>(internalFormat), size[0], 0, static_cast<GLenum>(format), static_cast<GLenum>(type), data);
+    glTexImage1D(target, level, static_cast<GLint>(internalFormat), size[0], 0, static_cast<GLenum>(format), static_cast<GLenum>(type), data);
 }
 
-void AbstractTexture::imageImplementationDSA(GLenum target, GLint mipLevel, InternalFormat internalFormat, const Math::Vector<1, GLsizei>& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data) {
-    glTextureImage1DEXT(_id, target, mipLevel, GLint(internalFormat), size[0], 0, static_cast<GLenum>(format), static_cast<GLenum>(type), data);
+void AbstractTexture::imageImplementationDSA(GLenum target, GLint level, InternalFormat internalFormat, const Math::Vector<1, GLsizei>& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data) {
+    glTextureImage1DEXT(_id, target, level, GLint(internalFormat), size[0], 0, static_cast<GLenum>(format), static_cast<GLenum>(type), data);
 }
 #endif
 
-void AbstractTexture::imageImplementationDefault(GLenum target, GLint mipLevel, InternalFormat internalFormat, const Vector2i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data) {
+void AbstractTexture::imageImplementationDefault(GLenum target, GLint level, InternalFormat internalFormat, const Vector2i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data) {
     bindInternal();
-    glTexImage2D(target, mipLevel, GLint(internalFormat), size.x(), size.y(), 0, static_cast<GLenum>(format), static_cast<GLenum>(type), data);
+    glTexImage2D(target, level, GLint(internalFormat), size.x(), size.y(), 0, static_cast<GLenum>(format), static_cast<GLenum>(type), data);
 }
 
 #ifndef MAGNUM_TARGET_GLES
-void AbstractTexture::imageImplementationDSA(GLenum target, GLint mipLevel, InternalFormat internalFormat, const Vector2i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data) {
-    glTextureImage2DEXT(_id, target, mipLevel, GLint(internalFormat), size.x(), size.y(), 0, static_cast<GLenum>(format), static_cast<GLenum>(type), data);
+void AbstractTexture::imageImplementationDSA(GLenum target, GLint level, InternalFormat internalFormat, const Vector2i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data) {
+    glTextureImage2DEXT(_id, target, level, GLint(internalFormat), size.x(), size.y(), 0, static_cast<GLenum>(format), static_cast<GLenum>(type), data);
 }
 #endif
 
-void AbstractTexture::imageImplementationDefault(GLenum target, GLint mipLevel, InternalFormat internalFormat, const Vector3i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data) {
+void AbstractTexture::imageImplementationDefault(GLenum target, GLint level, InternalFormat internalFormat, const Vector3i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data) {
     bindInternal();
     /** @todo Get some extension wrangler instead to avoid linker errors to glTexImage3D() on ES2 */
     #ifndef MAGNUM_TARGET_GLES2
-    glTexImage3D(target, mipLevel, GLint(internalFormat), size.x(), size.y(), size.z(), 0, static_cast<GLenum>(format), static_cast<GLenum>(type), data);
+    glTexImage3D(target, level, GLint(internalFormat), size.x(), size.y(), size.z(), 0, static_cast<GLenum>(format), static_cast<GLenum>(type), data);
     #else
     static_cast<void>(target);
-    static_cast<void>(mipLevel);
+    static_cast<void>(level);
     static_cast<void>(internalFormat);
     static_cast<void>(size);
     static_cast<void>(format);
@@ -286,41 +286,41 @@ void AbstractTexture::imageImplementationDefault(GLenum target, GLint mipLevel,
 }
 
 #ifndef MAGNUM_TARGET_GLES
-void AbstractTexture::imageImplementationDSA(GLenum target, GLint mipLevel, InternalFormat internalFormat, const Vector3i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data) {
-    glTextureImage3DEXT(_id, target, mipLevel, GLint(internalFormat), size.x(), size.y(), size.z(), 0, static_cast<GLenum>(format), static_cast<GLenum>(type), data);
+void AbstractTexture::imageImplementationDSA(GLenum target, GLint level, InternalFormat internalFormat, const Vector3i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data) {
+    glTextureImage3DEXT(_id, target, level, GLint(internalFormat), size.x(), size.y(), size.z(), 0, static_cast<GLenum>(format), static_cast<GLenum>(type), data);
 }
 #endif
 
 #ifndef MAGNUM_TARGET_GLES
-void AbstractTexture::subImageImplementationDefault(GLenum target, GLint mipLevel, const Math::Vector<1, GLint>& offset, const Math::Vector<1, GLsizei>& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data) {
+void AbstractTexture::subImageImplementationDefault(GLenum target, GLint level, const Math::Vector<1, GLint>& offset, const Math::Vector<1, GLsizei>& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data) {
     bindInternal();
-    glTexSubImage1D(target, mipLevel, offset[0], size[0], static_cast<GLenum>(format), static_cast<GLenum>(type), data);
+    glTexSubImage1D(target, level, offset[0], size[0], static_cast<GLenum>(format), static_cast<GLenum>(type), data);
 }
 
-void AbstractTexture::subImageImplementationDSA(GLenum target, GLint mipLevel, const Math::Vector<1, GLint>& offset, const Math::Vector<1, GLsizei>& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data) {
-    glTextureSubImage1DEXT(_id, target, mipLevel, offset[0], size[0], static_cast<GLenum>(format), static_cast<GLenum>(type), data);
+void AbstractTexture::subImageImplementationDSA(GLenum target, GLint level, const Math::Vector<1, GLint>& offset, const Math::Vector<1, GLsizei>& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data) {
+    glTextureSubImage1DEXT(_id, target, level, offset[0], size[0], static_cast<GLenum>(format), static_cast<GLenum>(type), data);
 }
 #endif
 
-void AbstractTexture::subImageImplementationDefault(GLenum target, GLint mipLevel, const Vector2i& offset, const Vector2i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data) {
+void AbstractTexture::subImageImplementationDefault(GLenum target, GLint level, const Vector2i& offset, const Vector2i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data) {
     bindInternal();
-    glTexSubImage2D(target, mipLevel, offset.x(), offset.y(), size.x(), size.y(), static_cast<GLenum>(format), static_cast<GLenum>(type), data);
+    glTexSubImage2D(target, level, offset.x(), offset.y(), size.x(), size.y(), static_cast<GLenum>(format), static_cast<GLenum>(type), data);
 }
 
 #ifndef MAGNUM_TARGET_GLES
-void AbstractTexture::subImageImplementationDSA(GLenum target, GLint mipLevel, const Vector2i& offset, const Vector2i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data) {
-    glTextureSubImage2DEXT(_id, target, mipLevel, offset.x(), offset.y(), size.x(), size.y(), static_cast<GLenum>(format), static_cast<GLenum>(type), data);
+void AbstractTexture::subImageImplementationDSA(GLenum target, GLint level, const Vector2i& offset, const Vector2i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data) {
+    glTextureSubImage2DEXT(_id, target, level, offset.x(), offset.y(), size.x(), size.y(), static_cast<GLenum>(format), static_cast<GLenum>(type), data);
 }
 #endif
 
-void AbstractTexture::subImageImplementationDefault(GLenum target, GLint mipLevel, const Vector3i& offset, const Vector3i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data) {
+void AbstractTexture::subImageImplementationDefault(GLenum target, GLint level, const Vector3i& offset, const Vector3i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data) {
     bindInternal();
     /** @todo Get some extension wrangler instead to avoid linker errors to glTexSubImage3D() on ES2 */
     #ifndef MAGNUM_TARGET_GLES2
-    glTexSubImage3D(target, mipLevel, offset.x(), offset.y(), offset.z(), size.x(), size.y(), size.z(), static_cast<GLenum>(format), static_cast<GLenum>(type), data);
+    glTexSubImage3D(target, level, offset.x(), offset.y(), offset.z(), size.x(), size.y(), size.z(), static_cast<GLenum>(format), static_cast<GLenum>(type), data);
     #else
     static_cast<void>(target);
-    static_cast<void>(mipLevel);
+    static_cast<void>(level);
     static_cast<void>(offset);
     static_cast<void>(size);
     static_cast<void>(format);
@@ -330,8 +330,8 @@ void AbstractTexture::subImageImplementationDefault(GLenum target, GLint mipLeve
 }
 
 #ifndef MAGNUM_TARGET_GLES
-void AbstractTexture::subImageImplementationDSA(GLenum target, GLint mipLevel, const Vector3i& offset, const Vector3i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data) {
-    glTextureSubImage3DEXT(_id, target, mipLevel, offset.x(), offset.y(), offset.z(), size.x(), size.y(), size.z(), static_cast<GLenum>(format), static_cast<GLenum>(type), data);
+void AbstractTexture::subImageImplementationDSA(GLenum target, GLint level, const Vector3i& offset, const Vector3i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data) {
+    glTextureSubImage3DEXT(_id, target, level, offset.x(), offset.y(), offset.z(), size.x(), size.y(), size.z(), static_cast<GLenum>(format), static_cast<GLenum>(type), data);
 }
 #endif
 

src/AbstractTexture.h

@@ -145,7 +145,7 @@ class MAGNUM_EXPORT AbstractTexture {
         /**
          * @brief Internal format
          *
-         * @see @ref Texture::setData() "setData()"
+         * @see @ref Texture::setImage() "setImage()"
          */
         enum class InternalFormat: GLint {
             /**
@@ -1175,36 +1175,36 @@ class MAGNUM_EXPORT AbstractTexture {
 
         #ifndef MAGNUM_TARGET_GLES
         typedef void(AbstractTexture::*Image1DImplementation)(GLenum, GLint, InternalFormat, const Math::Vector<1, GLsizei>&, AbstractImage::Format, AbstractImage::Type, const GLvoid*);
-        void MAGNUM_LOCAL imageImplementationDefault(GLenum target, GLint mipLevel, InternalFormat internalFormat, const Math::Vector<1, GLsizei>& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data);
-        void MAGNUM_LOCAL imageImplementationDSA(GLenum target, GLint mipLevel, InternalFormat internalFormat, const Math::Vector<1, GLsizei>& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data);
+        void MAGNUM_LOCAL imageImplementationDefault(GLenum target, GLint level, InternalFormat internalFormat, const Math::Vector<1, GLsizei>& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data);
+        void MAGNUM_LOCAL imageImplementationDSA(GLenum target, GLint level, InternalFormat internalFormat, const Math::Vector<1, GLsizei>& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data);
         static Image1DImplementation image1DImplementation;
         #endif
 
         typedef void(AbstractTexture::*Image2DImplementation)(GLenum, GLint, InternalFormat, const Vector2i&, AbstractImage::Format, AbstractImage::Type, const GLvoid*);
-        void MAGNUM_LOCAL imageImplementationDefault(GLenum target, GLint mipLevel, InternalFormat internalFormat, const Vector2i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data);
-        void MAGNUM_LOCAL imageImplementationDSA(GLenum target, GLint mipLevel, InternalFormat internalFormat, const Vector2i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data);
+        void MAGNUM_LOCAL imageImplementationDefault(GLenum target, GLint level, InternalFormat internalFormat, const Vector2i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data);
+        void MAGNUM_LOCAL imageImplementationDSA(GLenum target, GLint level, InternalFormat internalFormat, const Vector2i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data);
         static Image2DImplementation image2DImplementation;
 
         typedef void(AbstractTexture::*Image3DImplementation)(GLenum, GLint, InternalFormat, const Vector3i&, AbstractImage::Format, AbstractImage::Type, const GLvoid*);
-        void MAGNUM_LOCAL imageImplementationDefault(GLenum target, GLint mipLevel, InternalFormat internalFormat, const Vector3i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data);
-        void MAGNUM_LOCAL imageImplementationDSA(GLenum target, GLint mipLevel, InternalFormat internalFormat, const Vector3i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data);
+        void MAGNUM_LOCAL imageImplementationDefault(GLenum target, GLint level, InternalFormat internalFormat, const Vector3i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data);
+        void MAGNUM_LOCAL imageImplementationDSA(GLenum target, GLint level, InternalFormat internalFormat, const Vector3i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data);
         static Image3DImplementation image3DImplementation;
 
         #ifndef MAGNUM_TARGET_GLES
         typedef void(AbstractTexture::*SubImage1DImplementation)(GLenum, GLint, const Math::Vector<1, GLint>&, const Math::Vector<1, GLsizei>&, AbstractImage::Format, AbstractImage::Type, const GLvoid*);
-        void MAGNUM_LOCAL subImageImplementationDefault(GLenum target, GLint mipLevel, const Math::Vector<1, GLint>& offset, const Math::Vector<1, GLsizei>& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data);
-        void MAGNUM_LOCAL subImageImplementationDSA(GLenum target, GLint mipLevel, const Math::Vector<1, GLint>& offset, const Math::Vector<1, GLsizei>& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data);
+        void MAGNUM_LOCAL subImageImplementationDefault(GLenum target, GLint level, const Math::Vector<1, GLint>& offset, const Math::Vector<1, GLsizei>& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data);
+        void MAGNUM_LOCAL subImageImplementationDSA(GLenum target, GLint level, const Math::Vector<1, GLint>& offset, const Math::Vector<1, GLsizei>& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data);
         static SubImage1DImplementation subImage1DImplementation;
         #endif
 
         typedef void(AbstractTexture::*SubImage2DImplementation)(GLenum, GLint, const Vector2i&, const Vector2i&, AbstractImage::Format, AbstractImage::Type, const GLvoid*);
-        void MAGNUM_LOCAL subImageImplementationDefault(GLenum target, GLint mipLevel, const Vector2i& offset, const Vector2i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data);
-        void MAGNUM_LOCAL subImageImplementationDSA(GLenum target, GLint mipLevel, const Vector2i& offset, const Vector2i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data);
+        void MAGNUM_LOCAL subImageImplementationDefault(GLenum target, GLint level, const Vector2i& offset, const Vector2i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data);
+        void MAGNUM_LOCAL subImageImplementationDSA(GLenum target, GLint level, const Vector2i& offset, const Vector2i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data);
         static SubImage2DImplementation subImage2DImplementation;
 
         typedef void(AbstractTexture::*SubImage3DImplementation)(GLenum, GLint, const Vector3i&, const Vector3i&, AbstractImage::Format, AbstractImage::Type, const GLvoid*);
-        void MAGNUM_LOCAL subImageImplementationDefault(GLenum target, GLint mipLevel, const Vector3i& offset, const Vector3i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data);
-        void MAGNUM_LOCAL subImageImplementationDSA(GLenum target, GLint mipLevel, const Vector3i& offset, const Vector3i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data);
+        void MAGNUM_LOCAL subImageImplementationDefault(GLenum target, GLint level, const Vector3i& offset, const Vector3i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data);
+        void MAGNUM_LOCAL subImageImplementationDSA(GLenum target, GLint level, const Vector3i& offset, const Vector3i& size, AbstractImage::Format format, AbstractImage::Type type, const GLvoid* data);
         static SubImage3DImplementation subImage3DImplementation;
 
         void MAGNUM_LOCAL destroy();
@@ -1226,12 +1226,12 @@ template<> struct AbstractTexture::DataHelper<1> {
         (texture->*parameteriImplementation)(GL_TEXTURE_WRAP_S, static_cast<GLint>(wrapping.x()));
     }
 
-    template<class Image> inline static typename std::enable_if<Image::Dimensions == 1, void>::type set(AbstractTexture* texture, GLenum target, GLint mipLevel, InternalFormat internalFormat, Image* image) {
-        (texture->*image1DImplementation)(target, mipLevel, internalFormat, image->size(), image->format(), image->type(), image->data());
+    template<class Image> inline static typename std::enable_if<Image::Dimensions == 1, void>::type set(AbstractTexture* texture, GLenum target, GLint level, InternalFormat internalFormat, Image* image) {
+        (texture->*image1DImplementation)(target, level, internalFormat, image->size(), image->format(), image->type(), image->data());
     }
 
-    template<class Image> inline static typename std::enable_if<Image::Dimensions == 1, void>::type setSub(AbstractTexture* texture, GLenum target, GLint mipLevel, const Math::Vector<1, GLint>& offset, Image* image) {
-        (texture->*subImage1DImplementation)(target, mipLevel, offset, image->size(), image->format(), image->type(), image->data());
+    template<class Image> inline static typename std::enable_if<Image::Dimensions == 1, void>::type setSub(AbstractTexture* texture, GLenum target, GLint level, const Math::Vector<1, GLint>& offset, Image* image) {
+        (texture->*subImage1DImplementation)(target, level, offset, image->size(), image->format(), image->type(), image->data());
     }
 };
 #endif
@@ -1249,16 +1249,16 @@ template<> struct MAGNUM_EXPORT AbstractTexture::DataHelper<2> {
 
     static void setWrapping(AbstractTexture* texture, const Array2D<Wrapping>& wrapping);
 
-    template<class Image> inline static typename std::enable_if<Image::Dimensions == 2, void>::type set(AbstractTexture* texture, GLenum target, GLint mipLevel, InternalFormat internalFormat, Image* image) {
-        (texture->*image2DImplementation)(target, mipLevel, internalFormat, image->size(), image->format(), image->type(), image->data());
+    template<class Image> inline static typename std::enable_if<Image::Dimensions == 2, void>::type set(AbstractTexture* texture, GLenum target, GLint level, InternalFormat internalFormat, Image* image) {
+        (texture->*image2DImplementation)(target, level, internalFormat, image->size(), image->format(), image->type(), image->data());
     }
 
-    template<class Image> inline static typename std::enable_if<Image::Dimensions == 2, void>::type setSub(AbstractTexture* texture, GLenum target, GLint mipLevel, const Vector2i& offset, Image* image) {
-        (texture->*subImage2DImplementation)(target, mipLevel, offset, image->size(), image->format(), image->type(), image->data());
+    template<class Image> inline static typename std::enable_if<Image::Dimensions == 2, void>::type setSub(AbstractTexture* texture, GLenum target, GLint level, const Vector2i& offset, Image* image) {
+        (texture->*subImage2DImplementation)(target, level, offset, image->size(), image->format(), image->type(), image->data());
     }
 
-    template<class Image> inline static typename std::enable_if<Image::Dimensions == 1, void>::type setSub(AbstractTexture* texture, GLenum target, GLint mipLevel, const Vector2i& offset, Image* image) {
-        (texture->*subImage2DImplementation)(target, mipLevel, offset, Vector2i(image->size(), 1), image->format(), image->type(), image->data());
+    template<class Image> inline static typename std::enable_if<Image::Dimensions == 1, void>::type setSub(AbstractTexture* texture, GLenum target, GLint level, const Vector2i& offset, Image* image) {
+        (texture->*subImage2DImplementation)(target, level, offset, Vector2i(image->size(), 1), image->format(), image->type(), image->data());
     }
 };
 template<> struct MAGNUM_EXPORT AbstractTexture::DataHelper<3> {
@@ -1275,16 +1275,16 @@ template<> struct MAGNUM_EXPORT AbstractTexture::DataHelper<3> {
 
     static void setWrapping(AbstractTexture* texture, const Array3D<Wrapping>& wrapping);
 
-    template<class Image> inline static typename std::enable_if<Image::Dimensions == 3, void>::type set(AbstractTexture* texture, GLenum target, GLint mipLevel, InternalFormat internalFormat, Image* image) {
-        (texture->*image3DImplementation)(target, mipLevel, internalFormat, image->size(), image->format(), image->type(), image->data());
+    template<class Image> inline static typename std::enable_if<Image::Dimensions == 3, void>::type set(AbstractTexture* texture, GLenum target, GLint level, InternalFormat internalFormat, Image* image) {
+        (texture->*image3DImplementation)(target, level, internalFormat, image->size(), image->format(), image->type(), image->data());
     }
 
-    template<class Image> inline static typename std::enable_if<Image::Dimensions == 3, void>::type setSub(AbstractTexture* texture, GLenum target, GLint mipLevel, const Vector3i& offset, Image* image) {
-        (texture->*subImage3DImplementation)(target, mipLevel, offset, image->size(), image->format(), image->type(), image->data());
+    template<class Image> inline static typename std::enable_if<Image::Dimensions == 3, void>::type setSub(AbstractTexture* texture, GLenum target, GLint level, const Vector3i& offset, Image* image) {
+        (texture->*subImage3DImplementation)(target, level, offset, image->size(), image->format(), image->type(), image->data());
     }
 
-    template<class Image> inline static typename std::enable_if<Image::Dimensions == 2, void>::type setSub(AbstractTexture* texture, GLenum target, GLint mipLevel, const Vector3i& offset, Image* image) {
-        (texture->*subImage3DImplementation)(target, mipLevel, offset, Vector3i(image->size(), 1), image->format(), image->type(), image->data());
+    template<class Image> inline static typename std::enable_if<Image::Dimensions == 2, void>::type setSub(AbstractTexture* texture, GLenum target, GLint level, const Vector3i& offset, Image* image) {
+        (texture->*subImage3DImplementation)(target, level, offset, Vector3i(image->size(), 1), image->format(), image->type(), image->data());
     }
 };
 #endif

src/CubeMapTexture.h

@@ -51,8 +51,8 @@ Image2D positiveX({256, 256}, Image2D::Components::RGBA, Image2D::ComponentType:
 CubeMapTexture texture;
 texture.setMagnificationFilter(Texture2D::Filter::Linear)
     // ...
-    ->setData(CubeMapTexture::Coordinate::PositiveX, 0, Texture2D::Format::RGBA8, &positiveX)
-    ->setData(CubeMapTexture::Coordinate::NegativeX, 0, Texture2D::Format::RGBA8, &negativeX)
+    ->setImage(CubeMapTexture::Coordinate::PositiveX, 0, Texture2D::Format::RGBA8, &positiveX)
+    ->setImage(CubeMapTexture::Coordinate::NegativeX, 0, Texture2D::Format::RGBA8, &negativeX)
     // ...
 @endcode
 
@@ -108,22 +108,22 @@ class CubeMapTexture: public AbstractTexture {
         }
 
         /**
-         * @copydoc Texture::setData(GLint, InternalFormat, Image*)
+         * @copydoc Texture::setImage(GLint, InternalFormat, Image*)
          * @param coordinate    Coordinate
          * @return Pointer to self (for method chaining)
          */
-        template<class Image> inline CubeMapTexture* setData(Coordinate coordinate, GLint mipLevel, InternalFormat internalFormat, Image* image) {
-            DataHelper<2>::set(this, static_cast<GLenum>(coordinate), mipLevel, internalFormat, image);
+        template<class Image> inline CubeMapTexture* setImage(Coordinate coordinate, GLint level, InternalFormat internalFormat, Image* image) {
+            DataHelper<2>::set(this, static_cast<GLenum>(coordinate), level, internalFormat, image);
             return this;
         }
 
         /**
-         * @copydoc Texture::setSubData(GLint, const typename DimensionTraits<Dimensions, GLint>::VectorType&, Image*)
+         * @copydoc Texture::setSubImage(GLint, const typename DimensionTraits<Dimensions, GLint>::VectorType&, Image*)
          * @param coordinate    Coordinate
          * @return Pointer to self (for method chaining)
          */
-        template<class Image> inline CubeMapTexture* setSubData(Coordinate coordinate, GLint mipLevel, const Vector2i& offset, const Image* image) {
-            DataHelper<2>::setSub(this, static_cast<GLenum>(coordinate), mipLevel, offset, image);
+        template<class Image> inline CubeMapTexture* setSubImage(Coordinate coordinate, GLint level, const Vector2i& offset, const Image* image) {
+            DataHelper<2>::setSub(this, static_cast<GLenum>(coordinate), level, offset, image);
             return this;
         }
 

src/CubeMapTextureArray.h

@@ -33,9 +33,9 @@ See CubeMapTexture documentation for introduction.
 
 @section CubeMapTextureArray-usage Usage
 
-Common usage is to specify each layer and face separately using setSubData().
+Common usage is to specify each layer and face separately using setSubImage().
 You have to allocate the memory for all layers and faces first, possibly by
-passing properly sized empty Image to setData(). Example: array with 16
+passing properly sized empty Image to setImage(). Example: array with 16
 layers of cube map faces, each face consisting of six 64x64 images:
 @code
 Image3D dummy({64, 64, 16*6}, Image3D::Components::RGBA, Image3D::ComponentType::UnsignedByte, nullptr);
@@ -43,15 +43,15 @@ Image3D dummy({64, 64, 16*6}, Image3D::Components::RGBA, Image3D::ComponentType:
 CubeMapTextureArray texture;
 texture.setMagnificationFilter(CubeMapTextureArray::Filter::Linear)
     // ...
-    ->setData(0, CubeMapTextureArray::Format::RGBA8, &dummy);
+    ->setImage(0, CubeMapTextureArray::Format::RGBA8, &dummy);
 
 for(std::size_t i = 0; i != 16; ++i) {
     void* dataPositiveX = ...;
     Image2D imagePositiveX({64, 64}, Image3D::Components::RGBA, Image3D::ComponentType::UnsignedByte, imagePositiveX);
     // ...
 
-    texture->setSubData(i, CubeMapTextureArray::Coordinate::PositiveX, 0, imagePositiveX);
-    texture->setSubData(i, CubeMapTextureArray::Coordinate::NegativeX, 0, imageNegativeX);
+    texture->setSubImage(i, CubeMapTextureArray::Coordinate::PositiveX, 0, imagePositiveX);
+    texture->setSubImage(i, CubeMapTextureArray::Coordinate::NegativeX, 0, imageNegativeX);
     // ...
 }
 
@@ -98,57 +98,56 @@ class CubeMapTextureArray: public AbstractTexture {
         }
 
         /**
-         * @copydoc Texture::setData(GLint, InternalFormat, Image*)
+         * @copydoc Texture::setImage(GLint, InternalFormat, Image*)
          *
-         * Sets texture data from three-dimensional image for all cube faces
-         * for all layers. Each group of 6 2D images is one cube map layer.
-         * The images are ordered the same way as Coordinate enum.
+         * Sets texture image data from three-dimensional image for all cube
+         * faces for all layers. Each group of 6 2D images is one cube map
+         * layer. The images are ordered the same way as Coordinate enum.
          */
-        template<class T> inline CubeMapTextureArray* setData(GLint mipLevel, InternalFormat internalFormat, T* image) {
-            DataHelper<3>::set(this, GL_TEXTURE_CUBE_MAP_ARRAY, mipLevel, internalFormat, image);
+        template<class T> inline CubeMapTextureArray* setImage(GLint level, InternalFormat internalFormat, T* image) {
+            DataHelper<3>::set(this, GL_TEXTURE_CUBE_MAP_ARRAY, level, internalFormat, image);
             return this;
         }
 
         /**
-         * @brief Set texture subdata from 3D image
-         * @param mipLevel      Mip level
+         * @brief Set texture image 3D subdata
+         * @param level         Mip level
          * @param offset        Offset where to put data in the texture
          * @param image         Image3D, ImageWrapper3D, BufferImage3D or
          *      Trade::ImageData3D
          * @return Pointer to self (for method chaining)
          *
-         * Sets texture subdata from given image. The image is not deleted
-         * afterwards.
+         * Sets texture image subdata for more than one level/face at once.
+         * The image is not deleted afterwards.
          *
          * Z coordinate of @p offset specifies layer and cube map face. If
          * you want to start at given face in layer *n*, you have to specify
          * Z coordinate as @f$ 6n + i @f$, where i is face index as specified
          * in Coordinate enum.
          *
-         * @see setSubData(GLsizei, Coordinate, GLint, const Math::Vector<2, GLint>&, const Image*)
+         * @see setSubImage(GLsizei, Coordinate, GLint, const Math::Vector<2, GLint>&, const Image*)
          */
-        template<class Image> inline CubeMapTextureArray* setSubData(GLint mipLevel, const Vector3i& offset, const Image* image) {
-            DataHelper<3>::setSub(this, GL_TEXTURE_CUBE_MAP_ARRAY, mipLevel, offset, image, Vector3i(Math::Vector<Image::Dimensions, GLsizei>()));
+        template<class Image> inline CubeMapTextureArray* setSubImage(GLint level, const Vector3i& offset, const Image* image) {
+            DataHelper<3>::setSub(this, GL_TEXTURE_CUBE_MAP_ARRAY, level, offset, image, Vector3i(Math::Vector<Image::Dimensions, GLsizei>()));
             return this;
         }
 
         /**
-         * @brief Set texture subdata from 2D image
+         * @brief Set texture image 2D subdata
          * @param layer         Array layer
          * @param coordinate    Coordinate
-         * @param mipLevel      Mip level
+         * @param level         Mip level
          * @param offset        Offset where to put data in the texture
          * @param image         Image2D, ImageWrapper2D, BufferImage2D or
          *      Trade::ImageData2D
          * @return Pointer to self (for method chaining)
          *
-         * Sets texture subdata from given image. The image is not deleted
-         * afterwards.
+         * The image is not deleted afterwards.
          *
-         * @see setSubData(GLint, const Math::Vector<3, GLint>&, const Image*)
+         * @see setSubImage(GLint, const Math::Vector<3, GLint>&, const Image*)
          */
-        template<class Image> inline CubeMapTextureArray* setSubData(GLsizei layer, Coordinate coordinate, GLint mipLevel, const Vector2i& offset, const Image* image) {
-            DataHelper<3>::setSub(this, GL_TEXTURE_CUBE_MAP_ARRAY, mipLevel, Vector3i(offset, layer*6+static_cast<GLsizei>(coordinate)), image, Vector2i(Math::Vector<Image::Dimensions, GLsizei>()));
+        template<class Image> inline CubeMapTextureArray* setSubImage(GLsizei layer, Coordinate coordinate, GLint level, const Vector2i& offset, const Image* image) {
+            DataHelper<3>::setSub(this, GL_TEXTURE_CUBE_MAP_ARRAY, level, Vector3i(offset, layer*6+static_cast<GLsizei>(coordinate)), image, Vector2i(Math::Vector<Image::Dimensions, GLsizei>()));
             return this;
         }
 

src/Text/Font.cpp

@@ -86,7 +86,7 @@ Font::Font(FontRenderer& renderer, const std::string& fontFile, GLfloat size, co
     }
 
     /* Set texture data */
-    _texture.setData(0, Texture2D::InternalFormat::R8, &image);
+    _texture.setImage(0, Texture2D::InternalFormat::R8, &image);
 }
 
 void Font::create(FontRenderer& renderer, const std::string& fontFile) {

src/Texture.h

@@ -44,7 +44,7 @@ texture.setMagnificationFilter(Texture2D::Filter::Linear)
     ->setMinificationFilter(Texture2D::Filter::Linear, Texture2D::Mipmap::Linear)
     ->setWrapping(Texture2D::Wrapping::ClampToEdge)
     ->setMaxAnisotropy(Texture2D::maxSupportedAnisotropy)
-    ->setData(0, Texture2D::Format::RGBA8, &image)
+    ->setImage(0, Texture2D::Format::RGBA8, &image)
     ->generateMipmap();
 @endcode
 
@@ -66,9 +66,9 @@ information.
 You can create texture arrays by passing @ref Texture::Target "Texture2D::Target::Texture1DArray"
 or @ref Texture::Target "Texture3D::Target::Texture2DArray" to constructor.
 
-It is possible to specify each layer separately using setSubData(), but you
+It is possible to specify each layer separately using setSubImage(), but you
 have to allocate the memory for all layers first, possibly by passing properly
-sized empty Image to setData(). Example: 2D texture array with 16 layers of
+sized empty Image to setImage(). Example: 2D texture array with 16 layers of
 64x64 images:
 @code
 Image3D dummy({64, 64, 16}, Image3D::Components::RGBA, Image3D::ComponentType::UnsignedByte, nullptr);
@@ -76,12 +76,12 @@ Image3D dummy({64, 64, 16}, Image3D::Components::RGBA, Image3D::ComponentType::U
 Texture3D texture(Texture3D::Target::Texture2DArray);
 texture.setMagnificationFilter(Texture2D::Filter::Linear)
     // ...
-    ->setData(0, Texture2D::Format::RGBA8, &dummy);
+    ->setImage(0, Texture2D::Format::RGBA8, &dummy);
 
 for(std::size_t i = 0; i != 16; ++i) {
     void* data = ...;
     Image2D image({64, 64}, Image3D::Components::RGBA, Image3D::ComponentType::UnsignedByte, image);
-    texture->setSubData(0, Vector3i::zAxis(i), image);
+    texture->setSubImage(0, Vector3i::zAxis(i), image);
 }
 
 // ...
@@ -198,38 +198,39 @@ template<std::uint8_t dimensions> class Texture: public AbstractTexture {
         }
 
         /**
-         * @brief Set texture data
-         * @param mipLevel          Mip level
+         * @brief Set image data
+         * @param level             Mip level
          * @param internalFormat    Internal texture format
          * @param image             Image, ImageWrapper, BufferImage or
          *      Trade::ImageData of the same dimension count
          * @return Pointer to self (for method chaining)
          *
-         * Sets texture data from given image. The image is not deleted
-         * afterwards. If @extension{EXT,direct_state_access} is not available,
-         * the texture is bound to some layer before the operation.
+         * The image is not deleted afterwards.
+         *
+         * If @extension{EXT,direct_state_access} is not available, the
+         * texture is bound to some layer before the operation.
          * @see @fn_gl{ActiveTexture}, @fn_gl{BindTexture} and @fn_gl{TexImage1D}/
          *      @fn_gl{TexImage2D}/@fn_gl{TexImage3D} or
          *      @fn_gl_extension{TextureImage1D,EXT,direct_state_access}/
          *      @fn_gl_extension{TextureImage2D,EXT,direct_state_access}/
          *      @fn_gl_extension{TextureImage3D,EXT,direct_state_access}
          */
-        template<class Image> inline Texture<Dimensions>* setData(GLint mipLevel, InternalFormat internalFormat, Image* image) {
-            DataHelper<Dimensions>::set(this, _target, mipLevel, internalFormat, image);
+        template<class Image> inline Texture<Dimensions>* setImage(GLint level, InternalFormat internalFormat, Image* image) {
+            DataHelper<Dimensions>::set(this, _target, level, internalFormat, image);
             return this;
         }
 
         /**
-         * @brief Set texture subdata
-         * @param mipLevel          Mip level
+         * @brief Set image subdata
+         * @param level             Mip level
          * @param offset            Offset where to put data in the texture
          * @param image             Image, ImageWrapper, BufferImage or
          *      Trade::ImageData of the same or one less dimension count
          * @return Pointer to self (for method chaining)
          *
-         * Sets texture subdata from given image. The image is not deleted
-         * afterwards. The image can have either the same dimension count or
-         * have one dimension less, but at least one dimension.
+         * The image is not deleted afterwards. The image can have either the
+         * same dimension count or have one dimension less, but at least one
+         * dimension.
          *
          * If the image has one dimension less than the texture, the image is
          * taken as if it had the last dimension equal to 1. It can be used
@@ -244,8 +245,8 @@ template<std::uint8_t dimensions> class Texture: public AbstractTexture {
          *      @fn_gl_extension{TextureSubImage2D,EXT,direct_state_access}/
          *      @fn_gl_extension{TextureSubImage3D,EXT,direct_state_access}
          */
-        template<class Image> inline Texture<Dimensions>* setSubData(GLint mipLevel, const typename DimensionTraits<Dimensions, GLint>::VectorType& offset, Image* image) {
-            DataHelper<Dimensions>::setSub(this, _target, mipLevel, offset, image);
+        template<class Image> inline Texture<Dimensions>* setSubImage(GLint level, const typename DimensionTraits<Dimensions, GLint>::VectorType& offset, Image* image) {
+            DataHelper<Dimensions>::setSub(this, _target, level, offset, image);
             return this;
         }