From fdded7281d2bade01c4509cfb6e3bf1329ffbbf5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= Date: Fri, 11 Jan 2013 22:41:42 +0100 Subject: [PATCH] Renamed *Texture::set*Data() to set*Image(). Better consistency with OpenGL naming. --- src/AbstractImage.h | 2 +- src/AbstractTexture.cpp | 52 +++++++++++++++++------------------ src/AbstractTexture.h | 58 +++++++++++++++++++-------------------- src/CubeMapTexture.h | 16 +++++------ src/CubeMapTextureArray.h | 49 ++++++++++++++++----------------- src/Text/Font.cpp | 2 +- src/Texture.h | 39 +++++++++++++------------- 7 files changed, 109 insertions(+), 109 deletions(-) diff --git a/src/AbstractImage.h b/src/AbstractImage.h index 0ab1fd61c..dfbfbaf65 100644 --- a/src/AbstractImage.h +++ b/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). */ /** diff --git a/src/AbstractTexture.cpp b/src/AbstractTexture.cpp index cd8cd661c..6f07fd02e 100644 --- a/src/AbstractTexture.cpp +++ b/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(internalFormat), size[0], 0, static_cast(format), static_cast(type), data); + glTexImage1D(target, level, static_cast(internalFormat), size[0], 0, static_cast(format), static_cast(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(format), static_cast(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(format), static_cast(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(format), static_cast(type), data); + glTexImage2D(target, level, GLint(internalFormat), size.x(), size.y(), 0, static_cast(format), static_cast(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(format), static_cast(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(format), static_cast(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(format), static_cast(type), data); + glTexImage3D(target, level, GLint(internalFormat), size.x(), size.y(), size.z(), 0, static_cast(format), static_cast(type), data); #else static_cast(target); - static_cast(mipLevel); + static_cast(level); static_cast(internalFormat); static_cast(size); static_cast(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(format), static_cast(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(format), static_cast(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(format), static_cast(type), data); + glTexSubImage1D(target, level, offset[0], size[0], static_cast(format), static_cast(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(format), static_cast(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(format), static_cast(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(format), static_cast(type), data); + glTexSubImage2D(target, level, offset.x(), offset.y(), size.x(), size.y(), static_cast(format), static_cast(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(format), static_cast(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(format), static_cast(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(format), static_cast(type), data); + glTexSubImage3D(target, level, offset.x(), offset.y(), offset.z(), size.x(), size.y(), size.z(), static_cast(format), static_cast(type), data); #else static_cast(target); - static_cast(mipLevel); + static_cast(level); static_cast(offset); static_cast(size); static_cast(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(format), static_cast(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(format), static_cast(type), data); } #endif diff --git a/src/AbstractTexture.h b/src/AbstractTexture.h index 7425e1ac8..7c2b96cc8 100644 --- a/src/AbstractTexture.h +++ b/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(wrapping.x())); } - template inline static typename std::enable_if::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 inline static typename std::enable_if::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 inline static typename std::enable_if::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 inline static typename std::enable_if::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); - template inline static typename std::enable_if::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 inline static typename std::enable_if::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 inline static typename std::enable_if::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 inline static typename std::enable_if::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 inline static typename std::enable_if::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 inline static typename std::enable_if::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); - template inline static typename std::enable_if::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 inline static typename std::enable_if::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 inline static typename std::enable_if::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 inline static typename std::enable_if::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 inline static typename std::enable_if::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 inline static typename std::enable_if::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 diff --git a/src/CubeMapTexture.h b/src/CubeMapTexture.h index e53fa92ba..f2e9e60ee 100644 --- a/src/CubeMapTexture.h +++ b/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 inline CubeMapTexture* setData(Coordinate coordinate, GLint mipLevel, InternalFormat internalFormat, Image* image) { - DataHelper<2>::set(this, static_cast(coordinate), mipLevel, internalFormat, image); + template inline CubeMapTexture* setImage(Coordinate coordinate, GLint level, InternalFormat internalFormat, Image* image) { + DataHelper<2>::set(this, static_cast(coordinate), level, internalFormat, image); return this; } /** - * @copydoc Texture::setSubData(GLint, const typename DimensionTraits::VectorType&, Image*) + * @copydoc Texture::setSubImage(GLint, const typename DimensionTraits::VectorType&, Image*) * @param coordinate Coordinate * @return Pointer to self (for method chaining) */ - template inline CubeMapTexture* setSubData(Coordinate coordinate, GLint mipLevel, const Vector2i& offset, const Image* image) { - DataHelper<2>::setSub(this, static_cast(coordinate), mipLevel, offset, image); + template inline CubeMapTexture* setSubImage(Coordinate coordinate, GLint level, const Vector2i& offset, const Image* image) { + DataHelper<2>::setSub(this, static_cast(coordinate), level, offset, image); return this; } diff --git a/src/CubeMapTextureArray.h b/src/CubeMapTextureArray.h index ef5fe0124..9c8270233 100644 --- a/src/CubeMapTextureArray.h +++ b/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 inline CubeMapTextureArray* setData(GLint mipLevel, InternalFormat internalFormat, T* image) { - DataHelper<3>::set(this, GL_TEXTURE_CUBE_MAP_ARRAY, mipLevel, internalFormat, image); + template 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 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())); + template 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())); 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 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(coordinate)), image, Vector2i(Math::Vector())); + template 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(coordinate)), image, Vector2i(Math::Vector())); return this; } diff --git a/src/Text/Font.cpp b/src/Text/Font.cpp index 2161f4be7..757a070ad 100644 --- a/src/Text/Font.cpp +++ b/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) { diff --git a/src/Texture.h b/src/Texture.h index c3da55f57..e6013c716 100644 --- a/src/Texture.h +++ b/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 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 inline Texture* setData(GLint mipLevel, InternalFormat internalFormat, Image* image) { - DataHelper::set(this, _target, mipLevel, internalFormat, image); + template inline Texture* setImage(GLint level, InternalFormat internalFormat, Image* image) { + DataHelper::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 class Texture: public AbstractTexture { * @fn_gl_extension{TextureSubImage2D,EXT,direct_state_access}/ * @fn_gl_extension{TextureSubImage3D,EXT,direct_state_access} */ - template inline Texture* setSubData(GLint mipLevel, const typename DimensionTraits::VectorType& offset, Image* image) { - DataHelper::setSub(this, _target, mipLevel, offset, image); + template inline Texture* setSubImage(GLint level, const typename DimensionTraits::VectorType& offset, Image* image) { + DataHelper::setSub(this, _target, level, offset, image); return this; }