ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

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

Better consistency with OpenGL naming.
pull/7/head
Vladimír Vondruš 14 years ago
parent
90ba19b601
commit
fdded7281d
7 changed files with 109 additions and 109 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      src/AbstractImage.h
  2. 52
      src/AbstractTexture.cpp
  3. 58
      src/AbstractTexture.h
  4. 16
      src/CubeMapTexture.h
  5. 49
      src/CubeMapTextureArray.h
  6. 2
      src/Text/Font.cpp
  7. 39
      src/Texture.h

2
src/AbstractImage.h
Unescape View File

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

52
src/AbstractTexture.cpp
Unescape View File

@ -248,35 +248,35 @@ void AbstractTexture::parameterImplementationDSA(GLenum parameter, const GLfloat
glTextureParameterfvEXT(_id, _target, parameter, values); 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(); 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) { 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, mipLevel, GLint(internalFormat), size[0], 0, static_cast<GLenum>(format), static_cast<GLenum>(type), data); glTextureImage1DEXT(_id, target, level, GLint(internalFormat), size[0], 0, static_cast<GLenum>(format), static_cast<GLenum>(type), data);
} }
#endif #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(); 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 #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) { void AbstractTexture::imageImplementationDSA(GLenum target, GLint level, 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); glTextureImage2DEXT(_id, target, level, GLint(internalFormat), size.x(), size.y(), 0, static_cast<GLenum>(format), static_cast<GLenum>(type), data);
} }
#endif #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(); bindInternal();
/** @todo Get some extension wrangler instead to avoid linker errors to glTexImage3D() on ES2 */ /** @todo Get some extension wrangler instead to avoid linker errors to glTexImage3D() on ES2 */
#ifndef MAGNUM_TARGET_GLES2 #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 #else
static_cast<void>(target); static_cast<void>(target);
static_cast<void>(mipLevel); static_cast<void>(level);
static_cast<void>(internalFormat); static_cast<void>(internalFormat);
static_cast<void>(size); static_cast<void>(size);
static_cast<void>(format); static_cast<void>(format);
@ -286,41 +286,41 @@ void AbstractTexture::imageImplementationDefault(GLenum target, GLint mipLevel,
} }
#ifndef MAGNUM_TARGET_GLES #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) { void AbstractTexture::imageImplementationDSA(GLenum target, GLint level, 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); glTextureImage3DEXT(_id, target, level, GLint(internalFormat), size.x(), size.y(), size.z(), 0, static_cast<GLenum>(format), static_cast<GLenum>(type), data);
} }
#endif #endif
#ifndef MAGNUM_TARGET_GLES #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(); 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) { 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, mipLevel, offset[0], size[0], static_cast<GLenum>(format), static_cast<GLenum>(type), data); glTextureSubImage1DEXT(_id, target, level, offset[0], size[0], static_cast<GLenum>(format), static_cast<GLenum>(type), data);
} }
#endif #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(); 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 #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) { 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, mipLevel, offset.x(), offset.y(), size.x(), size.y(), static_cast<GLenum>(format), static_cast<GLenum>(type), data); glTextureSubImage2DEXT(_id, target, level, offset.x(), offset.y(), size.x(), size.y(), static_cast<GLenum>(format), static_cast<GLenum>(type), data);
} }
#endif #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(); bindInternal();
/** @todo Get some extension wrangler instead to avoid linker errors to glTexSubImage3D() on ES2 */ /** @todo Get some extension wrangler instead to avoid linker errors to glTexSubImage3D() on ES2 */
#ifndef MAGNUM_TARGET_GLES2 #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 #else
static_cast<void>(target); static_cast<void>(target);
static_cast<void>(mipLevel); static_cast<void>(level);
static_cast<void>(offset); static_cast<void>(offset);
static_cast<void>(size); static_cast<void>(size);
static_cast<void>(format); static_cast<void>(format);
@ -330,8 +330,8 @@ void AbstractTexture::subImageImplementationDefault(GLenum target, GLint mipLeve
} }
#ifndef MAGNUM_TARGET_GLES #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) { 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, mipLevel, offset.x(), offset.y(), offset.z(), size.x(), size.y(), size.z(), static_cast<GLenum>(format), static_cast<GLenum>(type), 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 #endif

58
src/AbstractTexture.h
Unescape View File

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

16
src/CubeMapTexture.h
Unescape View File

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

49
src/CubeMapTextureArray.h
Unescape View File

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

2
src/Text/Font.cpp
Unescape View File

@ -86,7 +86,7 @@ Font::Font(FontRenderer& renderer, const std::string& fontFile, GLfloat size, co
} }
/* Set texture data */ /* 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) { void Font::create(FontRenderer& renderer, const std::string& fontFile) {

39
src/Texture.h
Unescape View File

@ -44,7 +44,7 @@ texture.setMagnificationFilter(Texture2D::Filter::Linear)
->setMinificationFilter(Texture2D::Filter::Linear, Texture2D::Mipmap::Linear) ->setMinificationFilter(Texture2D::Filter::Linear, Texture2D::Mipmap::Linear)
->setWrapping(Texture2D::Wrapping::ClampToEdge) ->setWrapping(Texture2D::Wrapping::ClampToEdge)
->setMaxAnisotropy(Texture2D::maxSupportedAnisotropy) ->setMaxAnisotropy(Texture2D::maxSupportedAnisotropy)
->setData(0, Texture2D::Format::RGBA8, &image) ->setImage(0, Texture2D::Format::RGBA8, &image)
->generateMipmap(); ->generateMipmap();
@endcode @endcode
@ -66,9 +66,9 @@ information.
You can create texture arrays by passing @ref Texture::Target "Texture2D::Target::Texture1DArray" You can create texture arrays by passing @ref Texture::Target "Texture2D::Target::Texture1DArray"
or @ref Texture::Target "Texture3D::Target::Texture2DArray" to constructor. 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 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: 64x64 images:
@code @code
Image3D dummy({64, 64, 16}, Image3D::Components::RGBA, Image3D::ComponentType::UnsignedByte, nullptr); 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); Texture3D texture(Texture3D::Target::Texture2DArray);
texture.setMagnificationFilter(Texture2D::Filter::Linear) 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) { for(std::size_t i = 0; i != 16; ++i) {
void* data = ...; void* data = ...;
Image2D image({64, 64}, Image3D::Components::RGBA, Image3D::ComponentType::UnsignedByte, image); 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 * @brief Set image data
* @param mipLevel Mip level * @param level Mip level
* @param internalFormat Internal texture format * @param internalFormat Internal texture format
* @param image Image, ImageWrapper, BufferImage or * @param image Image, ImageWrapper, BufferImage or
* Trade::ImageData of the same dimension count * Trade::ImageData of the same dimension count
* @return Pointer to self (for method chaining) * @return Pointer to self (for method chaining)
* *
* Sets texture data from given image. The image is not deleted * The image is not deleted afterwards.
* afterwards. If @extension{EXT,direct_state_access} is not available, *
* the texture is bound to some layer before the operation. * 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}/ * @see @fn_gl{ActiveTexture}, @fn_gl{BindTexture} and @fn_gl{TexImage1D}/
* @fn_gl{TexImage2D}/@fn_gl{TexImage3D} or * @fn_gl{TexImage2D}/@fn_gl{TexImage3D} or
* @fn_gl_extension{TextureImage1D,EXT,direct_state_access}/ * @fn_gl_extension{TextureImage1D,EXT,direct_state_access}/
* @fn_gl_extension{TextureImage2D,EXT,direct_state_access}/ * @fn_gl_extension{TextureImage2D,EXT,direct_state_access}/
* @fn_gl_extension{TextureImage3D,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) { template<class Image> inline Texture<Dimensions>* setImage(GLint level, InternalFormat internalFormat, Image* image) {
DataHelper<Dimensions>::set(this, _target, mipLevel, internalFormat, image); DataHelper<Dimensions>::set(this, _target, level, internalFormat, image);
return this; return this;
} }
/** /**
* @brief Set texture subdata * @brief Set image subdata
* @param mipLevel Mip level * @param level Mip level
* @param offset Offset where to put data in the texture * @param offset Offset where to put data in the texture
* @param image Image, ImageWrapper, BufferImage or * @param image Image, ImageWrapper, BufferImage or
* Trade::ImageData of the same or one less dimension count * Trade::ImageData of the same or one less dimension count
* @return Pointer to self (for method chaining) * @return Pointer to self (for method chaining)
* *
* Sets texture subdata from given image. The image is not deleted * The image is not deleted afterwards. The image can have either the
* afterwards. The image can have either the same dimension count or * same dimension count or have one dimension less, but at least one
* have one dimension less, but at least one dimension. * dimension.
* *
* If the image has one dimension less than the texture, the image is * 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 * 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{TextureSubImage2D,EXT,direct_state_access}/
* @fn_gl_extension{TextureSubImage3D,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) { template<class Image> inline Texture<Dimensions>* setSubImage(GLint level, const typename DimensionTraits<Dimensions, GLint>::VectorType& offset, Image* image) {
DataHelper<Dimensions>::setSub(this, _target, mipLevel, offset, image); DataHelper<Dimensions>::setSub(this, _target, level, offset, image);
return this; return this;
} }

Write Preview
Loading…
Cancel
Save