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

Compressed image support, part 8: compressed image download. 

Only full images now, no tests yet.
pull/107/head
Vladimír Vondruš 11 years ago
parent
c470bc1e85
commit
cb6a1bd7b5
15 changed files with 506 additions and 3 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      doc/opengl-mapping.dox
  2. 53
      src/Magnum/AbstractTexture.cpp
  3. 7
      src/Magnum/AbstractTexture.h
  4. 90
      src/Magnum/CubeMapTexture.cpp
  5. 107
      src/Magnum/CubeMapTexture.h
  6. 10
      src/Magnum/CubeMapTextureArray.cpp
  7. 42
      src/Magnum/CubeMapTextureArray.h
  8. 16
      src/Magnum/Implementation/TextureState.cpp
  9. 2
      src/Magnum/Implementation/TextureState.h
  10. 10
      src/Magnum/RectangleTexture.cpp
  11. 38
      src/Magnum/RectangleTexture.h
  12. 10
      src/Magnum/Texture.cpp
  13. 68
      src/Magnum/Texture.h
  14. 10
      src/Magnum/TextureArray.cpp
  15. 44
      src/Magnum/TextureArray.h

2
doc/opengl-mapping.dox
Unescape View File

@ -174,7 +174,7 @@ OpenGL function | Matching API
@fn_gl{GetBufferParameter}, \n `glGetNamedBufferParameter()`, \n @fn_gl_extension{GetNamedBufferParameter,EXT,direct_state_access} | @ref Buffer::size()
@fn_gl2{GetBufferPointer,GetBufferPointerv}, \n `glGetNamedBufferPointer()`, \n @fn_gl_extension{GetNamedBufferPointer,EXT,direct_state_access} | not queryable, @ref Buffer::map() setter only
@fn_gl{GetBufferSubData}, \n `glGetNamedBufferSubData()`, \n @fn_gl_extension{GetNamedBufferSubData,EXT,direct_state_access} | @ref Buffer::data(), \n @ref Buffer::subData()
@fn_gl{GetCompressedTexImage}, \n `glGetnCompressedTexImage()`, \n @fn_gl_extension{GetnCompressedTexImage,ARB,robustness}, \n `glGetCompressedTextureImage()`, \n @fn_gl_extension{GetCompressedTextureImage,EXT,direct_state_access} | |
@fn_gl{GetCompressedTexImage}, \n `glGetnCompressedTexImage()`, \n @fn_gl_extension{GetnCompressedTexImage,ARB,robustness}, \n `glGetCompressedTextureImage()`, \n @fn_gl_extension{GetCompressedTextureImage,EXT,direct_state_access} | @ref Texture::compressedImage(), \n @ref TextureArray::compressedImage(), \n @ref CubeMapTexture::compressedImage(), \n @ref CubeMapTextureArray::compressedImage(), \n @ref RectangleTexture::compressedImage()
@fn_gl{GetCompressedTextureSubImage} | |
@fn_gl{GetDebugMessageLog} | |
@fn_gl{GetError} | @ref Renderer::error()

53
src/Magnum/AbstractTexture.cpp
Unescape View File

@ -1228,19 +1228,38 @@ void AbstractTexture::getImageImplementationDefault(const GLint level, const Col
glGetTexImage(_target, level, GLenum(format), GLenum(type), data);
}
void AbstractTexture::getCompressedImageImplementationDefault(const GLint level, std::size_t, GLvoid* const data) {
bindInternal();
glGetCompressedTexImage(_target, level, data);
}
void AbstractTexture::getImageImplementationDSA(const GLint level, const ColorFormat format, const ColorType type, const std::size_t dataSize, GLvoid* const data) {
glGetTextureImage(_id, level, GLenum(format), GLenum(type), dataSize, data);
}
void AbstractTexture::getCompressedImageImplementationDSA(const GLint level, const std::size_t dataSize, GLvoid* const data) {
glGetCompressedTextureImage(_id, level, dataSize, data);
}
void AbstractTexture::getImageImplementationDSAEXT(const GLint level, const ColorFormat format, const ColorType type, const std::size_t, GLvoid* const data) {
_flags |= ObjectFlag::Created;
glGetTextureImageEXT(_id, _target, level, GLenum(format), GLenum(type), data);
}
void AbstractTexture::getCompressedImageImplementationDSAEXT(const GLint level, std::size_t, GLvoid* const data) {
_flags |= ObjectFlag::Created;
glGetCompressedTextureImageEXT(_id, _target, level, data);
}
void AbstractTexture::getImageImplementationRobustness(const GLint level, const ColorFormat format, const ColorType type, const std::size_t dataSize, GLvoid* const data) {
bindInternal();
glGetnTexImageARB(_target, level, GLenum(format), GLenum(type), dataSize, data);
}
void AbstractTexture::getCompressedImageImplementationRobustness(const GLint level, const std::size_t dataSize, GLvoid* const data) {
bindInternal();
glGetnCompressedTexImageARB(_target, level, dataSize, data);
}
#endif
#ifndef MAGNUM_TARGET_GLES
@ -1382,6 +1401,7 @@ template<UnsignedInt dimensions> void AbstractTexture::image(GLint level, Image<
const Math::Vector<dimensions, Int> size = DataHelper<dimensions>::imageSize(*this, level);
const std::size_t dataSize = image.dataSize(size);
char* data = new char[dataSize];
Buffer::unbindInternal(Buffer::TargetHint::PixelPack);
(this->*Context::current()->state().texture->getImageImplementation)(level, image.format(), image.type(), dataSize, data);
image.setData(image.format(), image.type(), size, data);
@ -1405,6 +1425,39 @@ template void MAGNUM_EXPORT AbstractTexture::image<1>(GLint, BufferImage<1>&, Bu
template void MAGNUM_EXPORT AbstractTexture::image<2>(GLint, BufferImage<2>&, BufferUsage);
template void MAGNUM_EXPORT AbstractTexture::image<3>(GLint, BufferImage<3>&, BufferUsage);
template<UnsignedInt dimensions> void AbstractTexture::compressedImage(const GLint level, CompressedImage<dimensions>& image) {
const Math::Vector<dimensions, Int> size = DataHelper<dimensions>::imageSize(*this, level);
GLint dataSize;
(this->*Context::current()->state().texture->getLevelParameterivImplementation)(level, GL_TEXTURE_COMPRESSED_IMAGE_SIZE, &dataSize);
GLint format;
(this->*Context::current()->state().texture->getLevelParameterivImplementation)(level, GL_TEXTURE_INTERNAL_FORMAT, &format);
Containers::Array<char> data{std::size_t(dataSize)};
Buffer::unbindInternal(Buffer::TargetHint::PixelPack);
(this->*Context::current()->state().texture->getCompressedImageImplementation)(level, dataSize, data);
image.setData(CompressedColorFormat(format), size, std::move(data));
}
template void MAGNUM_EXPORT AbstractTexture::compressedImage<1>(GLint, CompressedImage<1>&);
template void MAGNUM_EXPORT AbstractTexture::compressedImage<2>(GLint, CompressedImage<2>&);
template void MAGNUM_EXPORT AbstractTexture::compressedImage<3>(GLint, CompressedImage<3>&);
template<UnsignedInt dimensions> void AbstractTexture::compressedImage(const GLint level, CompressedBufferImage<dimensions>& image, BufferUsage usage) {
const Math::Vector<dimensions, Int> size = DataHelper<dimensions>::imageSize(*this, level);
GLint dataSize;
(this->*Context::current()->state().texture->getLevelParameterivImplementation)(level, GL_TEXTURE_COMPRESSED_IMAGE_SIZE, &dataSize);
GLint format;
(this->*Context::current()->state().texture->getLevelParameterivImplementation)(level, GL_TEXTURE_INTERNAL_FORMAT, &format);
image.setData(CompressedColorFormat(format), size, {nullptr, std::size_t(dataSize)}, usage);
image.buffer().bindInternal(Buffer::TargetHint::PixelPack);
(this->*Context::current()->state().texture->getCompressedImageImplementation)(level, dataSize, nullptr);
}
template void MAGNUM_EXPORT AbstractTexture::compressedImage<1>(GLint, CompressedBufferImage<1>&, BufferUsage);
template void MAGNUM_EXPORT AbstractTexture::compressedImage<2>(GLint, CompressedBufferImage<2>&, BufferUsage);
template void MAGNUM_EXPORT AbstractTexture::compressedImage<3>(GLint, CompressedBufferImage<3>&, BufferUsage);
template<UnsignedInt dimensions> void AbstractTexture::subImage(const GLint level, const RangeTypeFor<dimensions, Int>& range, Image<dimensions>& image) {
createIfNotAlready();

7
src/Magnum/AbstractTexture.h
Unescape View File

@ -403,6 +403,8 @@ class MAGNUM_EXPORT AbstractTexture: public AbstractObject {
#ifndef MAGNUM_TARGET_GLES
template<UnsignedInt dimensions> void image(GLint level, Image<dimensions>& image);
template<UnsignedInt dimensions> void image(GLint level, BufferImage<dimensions>& image, BufferUsage usage);
template<UnsignedInt dimensions> void compressedImage(GLint level, CompressedImage<dimensions>& image);
template<UnsignedInt dimensions> void compressedImage(GLint level, CompressedBufferImage<dimensions>& image, BufferUsage usage);
template<UnsignedInt dimensions> void subImage(GLint level, const RangeTypeFor<dimensions, Int>& range, Image<dimensions>& image);
template<UnsignedInt dimensions> void subImage(GLint level, const RangeTypeFor<dimensions, Int>& range, BufferImage<dimensions>& image, BufferUsage usage);
#endif
@ -527,6 +529,11 @@ class MAGNUM_EXPORT AbstractTexture: public AbstractObject {
void MAGNUM_LOCAL getImageImplementationDSA(GLint level, ColorFormat format, ColorType type, std::size_t dataSize, GLvoid* data);
void MAGNUM_LOCAL getImageImplementationDSAEXT(GLint level, ColorFormat format, ColorType type, std::size_t dataSize, GLvoid* data);
void MAGNUM_LOCAL getImageImplementationRobustness(GLint level, ColorFormat format, ColorType type, std::size_t dataSize, GLvoid* data);
void MAGNUM_LOCAL getCompressedImageImplementationDefault(GLint level, std::size_t dataSize, GLvoid* data);
void MAGNUM_LOCAL getCompressedImageImplementationDSA(GLint level, std::size_t dataSize, GLvoid* data);
void MAGNUM_LOCAL getCompressedImageImplementationDSAEXT(GLint level, std::size_t dataSize, GLvoid* data);
void MAGNUM_LOCAL getCompressedImageImplementationRobustness(GLint level, std::size_t dataSize, GLvoid* data);
#endif
#ifndef MAGNUM_TARGET_GLES

90
src/Magnum/CubeMapTexture.cpp
Unescape View File

@ -85,10 +85,46 @@ BufferImage3D CubeMapTexture::image(const Int level, BufferImage3D&& image, cons
return std::move(image);
}
void CubeMapTexture::compressedImage(const Int level, CompressedImage3D& image) {
const Vector3i size{imageSize(level), 6};
GLint dataSize;
(this->*Context::current()->state().texture->getLevelParameterivImplementation)(level, GL_TEXTURE_COMPRESSED_IMAGE_SIZE, &dataSize);
GLint format;
(this->*Context::current()->state().texture->getLevelParameterivImplementation)(level, GL_TEXTURE_INTERNAL_FORMAT, &format);
Containers::Array<char> data{std::size_t(dataSize)};
Buffer::unbindInternal(Buffer::TargetHint::PixelPack);
glGetCompressedTextureImage(_id, level, dataSize, data);
image.setData(CompressedColorFormat(format), size, std::move(data));
}
CompressedImage3D CubeMapTexture::compressedImage(const Int level, CompressedImage3D&& image) {
compressedImage(level, image);
return std::move(image);
}
void CubeMapTexture::compressedImage(const Int level, CompressedBufferImage3D& image, const BufferUsage usage) {
const Vector3i size{imageSize(level), 6};
GLint dataSize;
(this->*Context::current()->state().texture->getLevelParameterivImplementation)(level, GL_TEXTURE_COMPRESSED_IMAGE_SIZE, &dataSize);
GLint format;
(this->*Context::current()->state().texture->getLevelParameterivImplementation)(level, GL_TEXTURE_INTERNAL_FORMAT, &format);
image.buffer().bindInternal(Buffer::TargetHint::PixelPack);
image.setData(CompressedColorFormat(format), size, {nullptr, std::size_t(dataSize)}, usage);
glGetCompressedTextureImage(_id, level, dataSize, nullptr);
}
CompressedBufferImage3D CubeMapTexture::compressedImage(const Int level, CompressedBufferImage3D&& image, const BufferUsage usage) {
compressedImage(level, image, usage);
return std::move(image);
}
void CubeMapTexture::image(const Coordinate coordinate, const Int level, Image2D& image) {
const Vector2i size = imageSize(level);
const std::size_t dataSize = image.dataSize(size);
char* data = new char[dataSize];
Buffer::unbindInternal(Buffer::TargetHint::PixelPack);
(this->*Context::current()->state().texture->getCubeImageImplementation)(coordinate, level, size, image.format(), image.type(), dataSize, data);
image.setData(image.format(), image.type(), size, data);
@ -114,6 +150,41 @@ BufferImage2D CubeMapTexture::image(const Coordinate coordinate, const Int level
return std::move(image);
}
void CubeMapTexture::compressedImage(const Coordinate coordinate, const Int level, CompressedImage2D& image) {
const Vector2i size = imageSize(level);
GLint dataSize;
(this->*Context::current()->state().texture->getLevelParameterivImplementation)(level, GL_TEXTURE_COMPRESSED_IMAGE_SIZE, &dataSize);
GLint format;
(this->*Context::current()->state().texture->getLevelParameterivImplementation)(level, GL_TEXTURE_INTERNAL_FORMAT, &format);
Containers::Array<char> data{std::size_t(dataSize)};
Buffer::unbindInternal(Buffer::TargetHint::PixelPack);
(this->*Context::current()->state().texture->getCompressedCubeImageImplementation)(coordinate, level, size, dataSize, data);
image.setData(CompressedColorFormat(format), size, std::move(data));
}
CompressedImage2D CubeMapTexture::compressedImage(const Coordinate coordinate, const Int level, CompressedImage2D&& image) {
compressedImage(coordinate, level, image);
return std::move(image);
}
void CubeMapTexture::compressedImage(const Coordinate coordinate, const Int level, CompressedBufferImage2D& image, const BufferUsage usage) {
const Vector2i size = imageSize(level);
GLint dataSize;
(this->*Context::current()->state().texture->getLevelParameterivImplementation)(level, GL_TEXTURE_COMPRESSED_IMAGE_SIZE, &dataSize);
GLint format;
(this->*Context::current()->state().texture->getLevelParameterivImplementation)(level, GL_TEXTURE_INTERNAL_FORMAT, &format);
image.setData(CompressedColorFormat(format), size, {nullptr, std::size_t(dataSize)}, usage);
image.buffer().bindInternal(Buffer::TargetHint::PixelPack);
(this->*Context::current()->state().texture->getCompressedCubeImageImplementation)(coordinate, level, size, dataSize, nullptr);
}
CompressedBufferImage2D CubeMapTexture::compressedImage(const Coordinate coordinate, const Int level, CompressedBufferImage2D&& image, const BufferUsage usage) {
compressedImage(coordinate, level, image, usage);
return std::move(image);
}
Image3D CubeMapTexture::subImage(const Int level, const Range3Di& range, Image3D&& image) {
this->subImage(level, range, image);
return std::move(image);
@ -214,19 +285,38 @@ void CubeMapTexture::getImageImplementationDefault(const Coordinate coordinate,
glGetTexImage(GLenum(coordinate), level, GLenum(format), GLenum(type), data);
}
void CubeMapTexture::getCompressedImageImplementationDefault(const Coordinate coordinate, const GLint level, const Vector2i&, std::size_t, GLvoid* const data) {
bindInternal();
glGetCompressedTexImage(GLenum(coordinate), level, data);
}
void CubeMapTexture::getImageImplementationDSA(const Coordinate coordinate, const GLint level, const Vector2i& size, const ColorFormat format, const ColorType type, const std::size_t dataSize, GLvoid* const data) {
glGetTextureSubImage(_id, level, 0, 0, GLenum(coordinate) - GL_TEXTURE_CUBE_MAP_POSITIVE_X, size.x(), size.y(), 1, GLenum(format), GLenum(type), dataSize, data);
}
void CubeMapTexture::getCompressedImageImplementationDSA(const Coordinate coordinate, const GLint level, const Vector2i& size, const std::size_t dataSize, GLvoid* const data) {
glGetCompressedTextureSubImage(_id, level, 0, 0, GLenum(coordinate) - GL_TEXTURE_CUBE_MAP_POSITIVE_X, size.x(), size.y(), 1, dataSize, data);
}
void CubeMapTexture::getImageImplementationDSAEXT(const Coordinate coordinate, const GLint level, const Vector2i&, const ColorFormat format, const ColorType type, std::size_t, GLvoid* const data) {
_flags |= ObjectFlag::Created;
glGetTextureImageEXT(_id, GLenum(coordinate), level, GLenum(format), GLenum(type), data);
}
void CubeMapTexture::getCompressedImageImplementationDSAEXT(const Coordinate coordinate, const GLint level, const Vector2i&, std::size_t, GLvoid* const data) {
_flags |= ObjectFlag::Created;
glGetCompressedTextureImageEXT(_id, GLenum(coordinate), level, data);
}
void CubeMapTexture::getImageImplementationRobustness(const Coordinate coordinate, const GLint level, const Vector2i&, const ColorFormat format, const ColorType type, const std::size_t dataSize, GLvoid* const data) {
bindInternal();
glGetnTexImageARB(GLenum(coordinate), level, GLenum(format), GLenum(type), dataSize, data);
}
void CubeMapTexture::getCompressedImageImplementationRobustness(const Coordinate coordinate, const GLint level, const Vector2i&, const std::size_t dataSize, GLvoid* const data) {
bindInternal();
glGetnCompressedTexImageARB(GLenum(coordinate), level, dataSize, data);
}
#endif
void CubeMapTexture::subImageImplementationDefault(const Coordinate coordinate, const GLint level, const Vector2i& offset, const Vector2i& size, const ColorFormat format, const ColorType type, const GLvoid* const data) {

107
src/Magnum/CubeMapTexture.h
Unescape View File

@ -478,6 +478,51 @@ class MAGNUM_EXPORT CubeMapTexture: public AbstractTexture {
*/
BufferImage3D image(Int level, BufferImage3D&& image, BufferUsage usage);
/**
* @brief Read given mip level of compressed texture to image
*
* Compression format and data size are taken from the texture, image
* size is taken using @ref imageSize().
* @see @fn_gl2{GetTextureLevelParameter,GetTexLevelParameter} with
* @def_gl{TEXTURE_COMPRESSED_IMAGE_SIZE},
* @def_gl{TEXTURE_INTERNAL_FORMAT}, @def_gl{TEXTURE_WIDTH},
* @def_gl{TEXTURE_HEIGHT}, then
* @fn_gl2{GetCompressedTextureImage,GetCompressedTexImage}
* @requires_gl45 Extension @extension{ARB,direct_state_access}
* @requires_gl Texture image queries are not available in OpenGL ES or
* WebGL. See @ref Framebuffer::read() for possible workaround.
*/
void compressedImage(Int level, CompressedImage3D& image);
/** @overload
*
* Convenience alternative to the above, example usage:
* @code
* CompressedImage3D image = texture.compressedImage(0, {});
* @endcode
*/
CompressedImage3D compressedImage(Int level, CompressedImage3D&& image);
/**
* @brief Read given mip level of compressed texture to buffer image
*
* See @ref compressedImage(Int, CompressedImage3D&) for more
* information.
* @requires_gl45 Extension @extension{ARB,direct_state_access}
* @requires_gl Texture image queries are not available in OpenGL ES or
* WebGL. See @ref Framebuffer::read() for possible workaround.
*/
void compressedImage(Int level, CompressedBufferImage3D& image, BufferUsage usage);
/** @overload
*
* Convenience alternative to the above, example usage:
* @code
* CompressedBufferImage3D image = texture.compressedImage(0, {}, BufferUsage::StaticRead);
* @endcode
*/
CompressedBufferImage3D compressedImage(Int level, CompressedBufferImage3D&& image, BufferUsage usage);
/**
* @brief Read given mip level and coordinate of texture to image
*
@ -534,6 +579,63 @@ class MAGNUM_EXPORT CubeMapTexture: public AbstractTexture {
*/
BufferImage2D image(Coordinate coordinate, Int level, BufferImage2D&& image, BufferUsage usage);
/**
* @brief Read given mip level and coordinate of compressed texture to image
*
* Compression format and data size are taken from the texture, image
* size is taken using @ref imageSize().
*
* If neither @extension{ARB,get_texture_sub_image} (part of OpenGL
* 4.5) nor @extension{EXT,direct_state_access} is available, the
* texture is bound before the operation (if not already). If either
* @extension{ARB,get_texture_sub_image} or @extension{ARB,robustness}
* is available, the operation is protected from buffer overflow.
* However, if @extension{ARB,get_texture_sub_image} is not available
* and both @extension{EXT,direct_state_access} and
* @extension{ARB,robustness} are available, the robust operation is
* preferred over DSA.
* @see @fn_gl2{GetTextureLevelParameter,GetTexLevelParameter},
* @fn_gl_extension{GetTextureLevelParameter,EXT,direct_state_access},
* eventually @fn_gl{GetTexLevelParameter} with
* @def_gl{TEXTURE_COMPRESSED_IMAGE_SIZE},
* @def_gl{TEXTURE_INTERNAL_FORMAT}, @def_gl{TEXTURE_WIDTH},
* @def_gl{TEXTURE_HEIGHT}, then @fn_gl{GetCompressedTextureSubImage},
* @fn_gl_extension{GetnCompressedTexImage,ARB,robustness},
* @fn_gl_extension{GetCompressedTextureImage,EXT,direct_state_access},
* eventually @fn_gl{GetCompressedTexImage}
* @requires_gl Texture image queries are not available in OpenGL ES or
* WebGL. See @ref Framebuffer::read() for possible workaround.
*/
void compressedImage(Coordinate coordinate, Int level, CompressedImage2D& image);
/** @overload
*
* Convenience alternative to the above, example usage:
* @code
* CompressedImage2D image = texture.compressedImage(CubeMapTexture::Coordinate::PositiveX, 0, {});
* @endcode
*/
CompressedImage2D compressedImage(Coordinate coordinate, Int level, CompressedImage2D&& image);
/**
* @brief Read given mip level and coordinate of compressed texture to buffer image
*
* See @ref compressedImage(Coordinate, Int, CompressedImage2D&) for
* more information.
* @requires_gl Texture image queries are not available in OpenGL ES or
* WebGL. See @ref Framebuffer::read() for possible workaround.
*/
void compressedImage(Coordinate coordinate, Int level, CompressedBufferImage2D& image, BufferUsage usage);
/** @overload
*
* Convenience alternative to the above, example usage:
* @code
* CompressedBufferImage2D image = texture.compressedImage(CubeMapTexture::Coordinate::PositiveX, 0, {}, BufferUsage::StaticRead);
* @endcode
*/
CompressedBufferImage2D compressedImage(Coordinate coordinate, Int level, CompressedBufferImage2D&& image, BufferUsage usage);
/**
* @copybrief Texture::subImage(Int, const RangeTypeFor<dimensions, Int>&, Image&)
*
@ -841,6 +943,11 @@ class MAGNUM_EXPORT CubeMapTexture: public AbstractTexture {
void MAGNUM_LOCAL getImageImplementationDSA(Coordinate coordinate, GLint level, const Vector2i& size, ColorFormat format, ColorType type, std::size_t dataSize, GLvoid* data);
void MAGNUM_LOCAL getImageImplementationDSAEXT(Coordinate coordinate, GLint level, const Vector2i& size, ColorFormat format, ColorType type, std::size_t dataSize, GLvoid* data);
void MAGNUM_LOCAL getImageImplementationRobustness(Coordinate coordinate, GLint level, const Vector2i& size, ColorFormat format, ColorType type, std::size_t dataSize, GLvoid* data);
void MAGNUM_LOCAL getCompressedImageImplementationDefault(Coordinate coordinate, GLint level, const Vector2i& size, std::size_t dataSize, GLvoid* data);
void MAGNUM_LOCAL getCompressedImageImplementationDSA(Coordinate coordinate, GLint level, const Vector2i& size, std::size_t dataSize, GLvoid* data);
void MAGNUM_LOCAL getCompressedImageImplementationDSAEXT(Coordinate coordinate, GLint level, const Vector2i& size, std::size_t dataSize, GLvoid* data);
void MAGNUM_LOCAL getCompressedImageImplementationRobustness(Coordinate coordinate, GLint level, const Vector2i& size, std::size_t dataSize, GLvoid* data);
#endif
void MAGNUM_LOCAL subImageImplementationDefault(Coordinate coordinate, GLint level, const Vector2i& offset, const Vector2i& size, ColorFormat format, ColorType type, const GLvoid* data);

10
src/Magnum/CubeMapTextureArray.cpp
Unescape View File

@ -59,6 +59,16 @@ BufferImage3D CubeMapTextureArray::image(const Int level, BufferImage3D&& image,
return std::move(image);
}
CompressedImage3D CubeMapTextureArray::compressedImage(const Int level, CompressedImage3D&& image) {
compressedImage(level, image);
return std::move(image);
}
CompressedBufferImage3D CubeMapTextureArray::compressedImage(const Int level, CompressedBufferImage3D&& image, const BufferUsage usage) {
compressedImage(level, image, usage);
return std::move(image);
}
Image3D CubeMapTextureArray::subImage(const Int level, const Range3Di& range, Image3D&& image) {
this->subImage(level, range, image);
return std::move(image);

42
src/Magnum/CubeMapTextureArray.h
Unescape View File

@ -413,6 +413,48 @@ class MAGNUM_EXPORT CubeMapTextureArray: public AbstractTexture {
*/
BufferImage3D image(Int level, BufferImage3D&& image, BufferUsage usage);
/**
* @copybrief Texture::compressedImage(Int, CompressedImage&)
*
* See @ref Texture::compressedImage(Int, CompressedImage&) for more
* information.
* @requires_gl Texture image queries are not available in OpenGL ES.
* See @ref Framebuffer::read() for possible workaround.
*/
void compressedImage(Int level, CompressedImage3D& image) {
AbstractTexture::compressedImage<3>(level, image);
}
/** @overload
*
* Convenience alternative to the above, example usage:
* @code
* CompressedImage3D image = texture.compressedImage(0, {});
* @endcode
*/
CompressedImage3D compressedImage(Int level, CompressedImage3D&& image);
/**
* @copybrief Texture::compressedImage(Int, CompressedBufferImage&, BufferUsage)
*
* See @ref Texture::compressedImage(Int, CompressedBufferImage&, BufferUsage)
* for more information.
* @requires_gl Texture image queries are not available in OpenGL ES.
* See @ref Framebuffer::read() for possible workaround.
*/
void compressedImage(Int level, CompressedBufferImage3D& image, BufferUsage usage) {
AbstractTexture::compressedImage<3>(level, image, usage);
}
/** @overload
*
* Convenience alternative to the above, example usage:
* @code
* CompressedBufferImage3D image = texture.compressedImage(0, {}, BufferUsage::StaticRead);
* @endcode
*/
CompressedBufferImage3D compressedImage(Int level, CompressedBufferImage3D&& image, BufferUsage usage);
/**
* @copybrief Texture::subImage(Int, const RangeTypeFor<dimensions, Int>&, Image&)
*

16
src/Magnum/Implementation/TextureState.cpp
Unescape View File

@ -223,31 +223,43 @@ TextureState::TextureState(Context& context, std::vector<std::string>& extension
if(context.isExtensionSupported<Extensions::GL::ARB::direct_state_access>()) {
/* Extension name added above */
getImageImplementation = &AbstractTexture::getImageImplementationDSA;
getCompressedImageImplementation = &AbstractTexture::getCompressedImageImplementationDSA;
} else if(context.isExtensionSupported<Extensions::GL::ARB::robustness>()) {
extensions.push_back(Extensions::GL::ARB::robustness::string());
getImageImplementation = &AbstractTexture::getImageImplementationRobustness;
getCompressedImageImplementation = &AbstractTexture::getCompressedImageImplementationRobustness;
} else if(context.isExtensionSupported<Extensions::GL::EXT::direct_state_access>()) {
/* Extension name added above */
getImageImplementation = &AbstractTexture::getImageImplementationDSAEXT;
getCompressedImageImplementation = &AbstractTexture::getCompressedImageImplementationDSAEXT;
} else getImageImplementation = &AbstractTexture::getImageImplementationDefault;
} else {
getImageImplementation = &AbstractTexture::getImageImplementationDefault;
getCompressedImageImplementation = &AbstractTexture::getCompressedImageImplementationDefault;
}
/* Image retrieval implementation for cube map */
if(context.isExtensionSupported<Extensions::GL::ARB::get_texture_sub_image>()) {
extensions.push_back(Extensions::GL::ARB::get_texture_sub_image::string());
getCubeImageImplementation = &CubeMapTexture::getImageImplementationDSA;
getCompressedCubeImageImplementation = &CubeMapTexture::getCompressedImageImplementationDSA;
} else if(context.isExtensionSupported<Extensions::GL::ARB::robustness>()) {
/* Extension name added above */
getCubeImageImplementation = &CubeMapTexture::getImageImplementationRobustness;
getCompressedCubeImageImplementation = &CubeMapTexture::getCompressedImageImplementationRobustness;
} else if(context.isExtensionSupported<Extensions::GL::EXT::direct_state_access>()) {
/* Extension name added above */
getCubeImageImplementation = &CubeMapTexture::getImageImplementationDSAEXT;
getCompressedCubeImageImplementation = &CubeMapTexture::getCompressedImageImplementationDSAEXT;
} else getCubeImageImplementation = &CubeMapTexture::getImageImplementationDefault;
} else {
getCubeImageImplementation = &CubeMapTexture::getImageImplementationDefault;
getCompressedCubeImageImplementation = &CubeMapTexture::getCompressedImageImplementationDefault;
}
#endif
/* Texture storage implementation for desktop and ES */

2
src/Magnum/Implementation/TextureState.h
Unescape View File

@ -70,6 +70,7 @@ struct TextureState {
#endif
#ifndef MAGNUM_TARGET_GLES
void(AbstractTexture::*getImageImplementation)(GLint, ColorFormat, ColorType, std::size_t, GLvoid*);
void(AbstractTexture::*getCompressedImageImplementation)(GLint, std::size_t, GLvoid*);
#endif
#ifndef MAGNUM_TARGET_GLES
void(AbstractTexture::*subImage1DImplementation)(GLint, const Math::Vector<1, GLint>&, const Math::Vector<1, GLsizei>&, ColorFormat, ColorType, const GLvoid*);
@ -94,6 +95,7 @@ struct TextureState {
#endif
#ifndef MAGNUM_TARGET_GLES
void(CubeMapTexture::*getCubeImageImplementation)(CubeMapTexture::Coordinate, GLint, const Vector2i&, ColorFormat, ColorType, std::size_t, GLvoid*);
void(CubeMapTexture::*getCompressedCubeImageImplementation)(CubeMapTexture::Coordinate, GLint, const Vector2i&, std::size_t, GLvoid*);
#endif
void(CubeMapTexture::*cubeSubImageImplementation)(CubeMapTexture::Coordinate, GLint, const Vector2i&, const Vector2i&, ColorFormat, ColorType, const GLvoid*);
void(CubeMapTexture::*cubeCompressedSubImageImplementation)(CubeMapTexture::Coordinate, GLint, const Vector2i&, const Vector2i&, CompressedColorFormat, Containers::ArrayView<const GLvoid>);

10
src/Magnum/RectangleTexture.cpp
Unescape View File

@ -58,6 +58,16 @@ BufferImage2D RectangleTexture::image(BufferImage2D&& image, const BufferUsage u
return std::move(image);
}
CompressedImage2D RectangleTexture::compressedImage(CompressedImage2D&& image) {
compressedImage(image);
return std::move(image);
}
CompressedBufferImage2D RectangleTexture::compressedImage(CompressedBufferImage2D&& image, const BufferUsage usage) {
compressedImage(image, usage);
return std::move(image);
}
Image2D RectangleTexture::subImage(const Range2Di& range, Image2D&& image) {
this->subImage(range, image);
return std::move(image);

38
src/Magnum/RectangleTexture.h
Unescape View File

@ -314,6 +314,44 @@ class MAGNUM_EXPORT RectangleTexture: public AbstractTexture {
*/
BufferImage2D image(BufferImage2D&& image, BufferUsage usage);
/**
* @brief Read compressed texture to image
*
* See @ref Texture::compressedImage(Int, CompressedImage&) for more
* information.
*/
void compressedImage(CompressedImage2D& image) {
AbstractTexture::compressedImage<2>(0, image);
}
/** @overload
*
* Convenience alternative to the above, example usage:
* @code
* CompressedImage2D image = texture.compressedimage({});
* @endcode
*/
CompressedImage2D compressedImage(CompressedImage2D&& image);
/**
* @brief Read compressed texture to buffer image
*
* See @ref Texture::compressedImage(Int, CompressedBufferImage&, BufferUsage)
* for more information.
*/
void compressedImage(CompressedBufferImage2D& image, BufferUsage usage) {
AbstractTexture::compressedImage<2>(0, image, usage);
}
/** @overload
*
* Convenience alternative to the above, example usage:
* @code
* CompressedBufferImage2D image = texture.compressedImage({}, BufferUsage::StaticRead);
* @endcode
*/
CompressedBufferImage2D compressedImage(CompressedBufferImage2D&& image, BufferUsage usage);
/**
* @copybrief Texture::subImage(Int, const RangeTypeFor<dimensions, Int>&, Image&)
*

10
src/Magnum/Texture.cpp
Unescape View File

@ -73,6 +73,16 @@ template<UnsignedInt dimensions> BufferImage<dimensions> Texture<dimensions>::im
return std::move(image);
}
template<UnsignedInt dimensions> CompressedImage<dimensions> Texture<dimensions>::compressedImage(const Int level, CompressedImage<dimensions>&& image) {
compressedImage(level, image);
return std::move(image);
}
template<UnsignedInt dimensions> CompressedBufferImage<dimensions> Texture<dimensions>::compressedImage(const Int level, CompressedBufferImage<dimensions>&& image, const BufferUsage usage) {
compressedImage(level, image, usage);
return std::move(image);
}
template<UnsignedInt dimensions> Image<dimensions> Texture<dimensions>::subImage(const Int level, const RangeTypeFor<dimensions, Int>& range, Image<dimensions>&& image) {
this->subImage(level, range, image);
return std::move(image);

68
src/Magnum/Texture.h
Unescape View File

@ -697,6 +697,74 @@ template<UnsignedInt dimensions> class Texture: public AbstractTexture {
*/
BufferImage<dimensions> image(Int level, BufferImage<dimensions>&& image, BufferUsage usage);
/**
* @brief Read given mip level of compressed texture to image
* @param level Mip level
* @param image Image where to put the compressed data
*
* Compression format and data size are taken from the texture, image
* size is taken using @ref imageSize().
*
* If neither @extension{ARB,direct_state_access} (part of OpenGL 4.5)
* nor @extension{EXT,direct_state_access} is available, the texture is
* bound before the operation (if not already). If either
* @extension{ARB,direct_state_access} or @extension{ARB,robustness}
* is available, the operation is protected from buffer overflow.
* However, if @extension{ARB,direct_state_access} is not available and
* both @extension{EXT,direct_state_access} and @extension{ARB,robustness}
* are available, the robust operation is preferred over DSA.
* @see @fn_gl2{GetTextureLevelParameter,GetTexLevelParameter},
* @fn_gl_extension{GetTextureLevelParameter,EXT,direct_state_access},
* eventually @fn_gl{GetTexLevelParameter} with
* @def_gl{TEXTURE_COMPRESSED_IMAGE_SIZE},
* @def_gl{TEXTURE_INTERNAL_FORMAT}, @def_gl{TEXTURE_WIDTH},
* @def_gl{TEXTURE_HEIGHT}, @def_gl{TEXTURE_DEPTH}, then
* @fn_gl2{GetCompressedTextureImage,GetCompressedTexImage},
* @fn_gl_extension{GetnCompressedTexImage,ARB,robustness},
* @fn_gl_extension{GetCompressedTextureImage,EXT,direct_state_access},
* eventually @fn_gl{GetCompressedTexImage}
* @requires_gl Texture image queries are not available in OpenGL ES or
* WebGL. See @ref Framebuffer::read() for possible workaround.
*/
void compressedImage(Int level, CompressedImage<dimensions>& image) {
AbstractTexture::compressedImage<dimensions>(level, image);
}
/** @overload
*
* Convenience alternative to the above, example usage:
* @code
* CompressedImage2D image = texture.compressedImage(0, {});
* @endcode
*/
CompressedImage<dimensions> compressedImage(Int level, CompressedImage<dimensions>&& image);
/**
* @brief Read given mip level of compressed texture to buffer image
* @param level Mip level
* @param image Buffer image where to put the compressed data
* @param usage Buffer usage
*
* See @ref compressedImage(Int, CompressedImage&) for more
* information.
* @requires_gl Texture image queries are not available in OpenGL ES or
* WebGL. See @ref Framebuffer::read() for possible workaround.
* @todo Make it more flexible (usable with
* @extension{ARB,buffer_storage}, avoiding relocations...)
*/
void compressedImage(Int level, CompressedBufferImage<dimensions>& image, BufferUsage usage) {
AbstractTexture::compressedImage<dimensions>(level, image, usage);
}
/** @overload
*
* Convenience alternative to the above, example usage:
* @code
* CompressedBufferImage2D image = texture.compressedImage(0, {}, BufferUsage::StaticRead);
* @endcode
*/
CompressedBufferImage<dimensions> compressedImage(Int level, CompressedBufferImage<dimensions>&& image, BufferUsage usage);
/**
* @brief Read range of given texture mip level to image
* @param level Mip level

10
src/Magnum/TextureArray.cpp
Unescape View File

@ -65,6 +65,16 @@ template<UnsignedInt dimensions> BufferImage<dimensions+1> TextureArray<dimensio
return std::move(image);
}
template<UnsignedInt dimensions> CompressedImage<dimensions+1> TextureArray<dimensions>::compressedImage(const Int level, CompressedImage<dimensions+1>&& image) {
compressedImage(level, image);
return std::move(image);
}
template<UnsignedInt dimensions> CompressedBufferImage<dimensions+1> TextureArray<dimensions>::compressedImage(const Int level, CompressedBufferImage<dimensions+1>&& image, const BufferUsage usage) {
compressedImage(level, image, usage);
return std::move(image);
}
template<UnsignedInt dimensions> Image<dimensions+1> TextureArray<dimensions>::subImage(const Int level, const RangeTypeFor<dimensions+1, Int>& range, Image<dimensions+1>&& image) {
this->subImage(level, range, image);
return std::move(image);

44
src/Magnum/TextureArray.h
Unescape View File

@ -436,6 +436,50 @@ template<UnsignedInt dimensions> class TextureArray: public AbstractTexture {
*/
BufferImage<dimensions+1> image(Int level, BufferImage<dimensions+1>&& image, BufferUsage usage);
/**
* @copybrief Texture::compressedImage(Int, CompressedImage&)
* @return Reference to self (for method chaining)
*
* See @ref Texture::compressedImage(Int, CompressedImage&) for more
* information.
* @requires_gl Texture image queries are not available in OpenGL ES or
* WebGL. See @ref Framebuffer::read() for possible workaround.
*/
void compressedImage(Int level, CompressedImage<dimensions+1>& image) {
AbstractTexture::compressedImage<dimensions+1>(level, image);
}
/** @overload
*
* Convenience alternative to the above, example usage:
* @code
* CompressedImage3D image = texture.compressedImage(0, {});
* @endcode
*/
CompressedImage<dimensions+1> compressedImage(Int level, CompressedImage<dimensions+1>&& image);
/**
* @copybrief Texture::compressedImage(Int, CompressedBufferImage&, BufferUsage)
* @return Reference to self (for method chaining)
*
* See @ref Texture::compressedImage(Int, CompressedBufferImage&, BufferUsage)
* for more information.
* @requires_gl Texture image queries are not available in OpenGL ES or
* WebGL. See @ref Framebuffer::read() for possible workaround.
*/
void compressedImage(Int level, CompressedBufferImage<dimensions+1>& image, BufferUsage usage) {
AbstractTexture::compressedImage<dimensions+1>(level, image, usage);
}
/** @overload
*
* Convenience alternative to the above, example usage:
* @code
* CompressedBufferImage3D image = texture.compressedImage(0, {}, BufferUsage::StaticRead);
* @endcode
*/
CompressedBufferImage<dimensions+1> compressedImage(Int level, CompressedBufferImage<dimensions+1>&& image, BufferUsage usage);
/**
* @copybrief Texture::subImage(Int, const RangeTypeFor<dimensions, Int>&, Image&)
*

Write Preview
Loading…
Cancel
Save