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

Rename pixelSize() and other helpers to pixelFormatSize() etc. 

For consistency with how VertexFormat and other enum helpers are named.
The compressedBlockSize() and compressedBlockDataSize() is also renamed
to compressedPixelFormatBlockSize() and
compressedPixelFormatBlockDataSize().

While backwards compatibility aliases are in place, a breaking change
is that Image classes now look for pixelFormatSize() instead of
pixelSize(). This is used e.g. when passing GL::PixelFormat /
GL::PixelType to the image classes, instead of the generic PixelFormat.
While useful, it's unlikely that any project was defining their own
pixel format enum and pixelSize() for a D3D or Metal renderer or
whatnot, so the breakage should have no practical impact.
pull/578/head
Vladimír Vondruš 4 years ago
parent
708526f331
commit
03cd5d3fb5
24 changed files with 260 additions and 196 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. 8
      doc/changelog-old.dox
  2. 17
      doc/changelog.dox
  3. 8
      src/Magnum/GL/AbstractTexture.cpp
  4. 2
      src/Magnum/GL/BufferImage.cpp
  5. 9
      src/Magnum/GL/BufferImage.h
  6. 8
      src/Magnum/GL/CubeMapTexture.cpp
  7. 4
      src/Magnum/GL/PixelFormat.cpp
  8. 18
      src/Magnum/GL/PixelFormat.h
  9. 18
      src/Magnum/GL/Test/PixelFormatTest.cpp
  10. 4
      src/Magnum/Image.cpp
  11. 38
      src/Magnum/Image.h
  12. 4
      src/Magnum/ImageView.cpp
  13. 52
      src/Magnum/ImageView.h
  14. 24
      src/Magnum/PixelFormat.cpp
  15. 68
      src/Magnum/PixelFormat.h
  16. 14
      src/Magnum/PixelStorage.h
  17. 8
      src/Magnum/Test/ImageTest.cpp
  18. 8
      src/Magnum/Test/ImageViewTest.cpp
  19. 72
      src/Magnum/Test/PixelFormatTest.cpp
  20. 40
      src/Magnum/Test/PixelStorageTest.cpp
  21. 2
      src/Magnum/Trade/ImageData.cpp
  22. 20
      src/Magnum/Trade/ImageData.h
  23. 8
      src/Magnum/Trade/Test/ImageDataTest.cpp
  24. 2
      src/Magnum/Trade/imageconverter.cpp

8
doc/changelog-old.dox
Unescape View File

@ -51,7 +51,7 @@ Released 2018-05-01, tagged as
@subsection changelog-2018-04-new New features
- New @ref PixelFormat / @ref CompressedPixelFormat enums containing generic
API-independent pixel formats, together with @ref pixelSize(),
API-independent pixel formats, together with @cpp pixelSize() @ce,
@ref pixelFormatWrap() / @ref pixelFormatUnwrap(),
@ref compressedPixelFormatWrap() / @ref compressedPixelFormatUnwrap() and @ref isPixelFormatImplementationSpecific() /
@ref isCompressedPixelFormatImplementationSpecific() utilities now used by
@ -252,12 +252,12 @@ Released 2018-05-01, tagged as
but marked as deprecated. Use either the generic values or
@ref GL::PixelFormat (together with @ref GL::PixelType) and
@ref GL::CompressedPixelFormat instead.
- `PixelStorage::pixelSize()` was deprecated, use @ref GL::pixelSize() or
@ref Magnum::pixelSize() instead
- `PixelStorage::pixelSize()` was deprecated, use @cpp GL::pixelSize() @ce
or @cpp Magnum::pixelSize() @ce instead
- `PixelStorage::dataProperties(GL::PixelFormat, GL::PixelSize, const Vector3i&)`
was deprecated for being too GL-specific, use
@ref PixelStorage::dataProperties(std::size_t, const Vector3i&) const
together with @ref GL::pixelSize() instead
together with @cpp GL::pixelSize() @ce instead
- `Image*::type()` functions are deprecated as these are too GL-specific. The
second format specifier is now available through @ref Image::formatExtra(),
@ref ImageView::formatExtra() and @ref Trade::ImageData::formatExtra()

17
doc/changelog.dox
Unescape View File

@ -769,6 +769,12 @@ See also:
the canvas and status elements from the JS `Module`. See
@ref platforms-html5-apps and [mosra/magnum#481](https://github.com/mosra/magnum/pull/481)
for details.
- @cpp pixelSize() @ce, @cpp GL::pixelSize() @ce, @cpp compressedBlockSize() @ce
and @cpp compressedBlockDataSize() @ce is deprecated in favor of
@ref pixelFormatSize(), @ref GL::pixelFormatSize(),
@ref compressedPixelFormatBlockSize() and
@ref compressedPixelFormatBlockDataSize() for consistency with similar APIs
for @ref VertexFormat and other format enums
- Templated variants of @ref DebugTools::bufferData() and
@ref DebugTools::bufferSubData() are deprecated in favor of the
non-templated API together with @relativeref{Corrade,Containers::arrayCast()}.
@ -1001,6 +1007,11 @@ See also:
is included in affected headers for implicit conversions from/to a
@ref std::string, but in some cases you may be forced to change the code
that uses those APIs.
- @ref Image, @ref ImageView and @ref Trade::ImageData now look for a
@cpp pixelFormatSize() @ce API via ADL instead of @cpp pixelSize() @ce. In
case you were passing a custom pixel format enum to the image classes, you
have provide a size query function with the new name to make your code
compile again.
- @ref GL::TextureFormat::SR8 and @ref GL::TextureFormat::SRG8 were present
on ES2 builds by mistake --- the @gl_extension{EXT,texture_sRGB_R8} and
@gl_extension{EXT,texture_sRGB_RG8} extensions require OpenGL ES 3.0 at
@ -1921,9 +1932,9 @@ Released 2019-10-24, tagged as
@ref PixelFormat::RGB8Srgb and @ref PixelFormat::RGBA8Srgb sRGB pixel
formats as well as their conversion to corresponding GL/Vulkan formats in
@ref GL::pixelFormat() and @ref Vk::vkFormat(Magnum::PixelFormat)
- New @ref compressedBlockSize() and @ref compressedBlockDataSize() utilities
for querying parameters of @ref CompressedPixelFormat entries, similar to
what @ref pixelSize() is for @ref PixelFormat
- New @cpp compressedBlockSize() @ce and @cpp compressedBlockDataSize() @ce
utilities for querying parameters of @ref CompressedPixelFormat entries,
similar to what @cpp pixelSize() @ce is for @ref PixelFormat
@subsubsection changelog-2019-10-new-audio Audio library

8
src/Magnum/GL/AbstractTexture.cpp
Unescape View File

@ -1564,7 +1564,7 @@ void AbstractTexture::imageImplementationSvga3DSliceBySlice(const GLenum target,
DSA cleanness is not worth it. */
/** @todo this will break when we support uploading from buffer offset (i.e. data != nullptr) */
if(target == GL_TEXTURE_1D_ARRAY && data && size.y() > 1)
subImageImplementationSvga3DSliceBySlice<&AbstractTexture::subImage2DImplementationDefault>(level, {0, 1}, {size.x(), size.y() - 1}, format, type, static_cast<const char*>(data) + std::get<1>(storage.dataProperties(pixelSize(format, type), {size, 1})).x(), storage);
subImageImplementationSvga3DSliceBySlice<&AbstractTexture::subImage2DImplementationDefault>(level, {0, 1}, {size.x(), size.y() - 1}, format, type, static_cast<const char*>(data) + std::get<1>(storage.dataProperties(pixelFormatSize(format, type), {size, 1})).x(), storage);
}
#endif
@ -1579,7 +1579,7 @@ template<void(AbstractTexture::*original)(GLint, const Vector2i&, const Vector2i
/* Upload the data slice by slice only if this is an array texture and we
are copying from user memory (not from a buffer) */
if(_target == GL_TEXTURE_1D_ARRAY && data) {
const std::size_t stride = std::get<1>(storage.dataProperties(pixelSize(format, type), {size, 1})).x();
const std::size_t stride = std::get<1>(storage.dataProperties(pixelFormatSize(format, type), {size, 1})).x();
for(Int i = 0; i != size.y(); ++i)
(this->*original)(level, {offset.x(), offset.y() + i}, {size.x(), 1}, format, type, static_cast<const char*>(data) + stride*i, storage);
@ -1637,7 +1637,7 @@ void AbstractTexture::imageImplementationSvga3DSliceBySlice(GLint level, Texture
#endif
) && data && size.z() > 1)
{
subImageImplementationSvga3DSliceBySlice<&AbstractTexture::subImage3DImplementationDefault>(level, {0, 0, 1}, {size.xy(), size.z() - 1}, format, type, static_cast<const char*>(data) + std::get<1>(storage.dataProperties(pixelSize(format, type), size)).xy().product(), storage);
subImageImplementationSvga3DSliceBySlice<&AbstractTexture::subImage3DImplementationDefault>(level, {0, 0, 1}, {size.xy(), size.z() - 1}, format, type, static_cast<const char*>(data) + std::get<1>(storage.dataProperties(pixelFormatSize(format, type), size)).xy().product(), storage);
}
}
#endif
@ -1664,7 +1664,7 @@ template<void(AbstractTexture::*original)(GLint, const Vector3i&, const Vector3i
#endif
)
{
const std::size_t stride = std::get<1>(storage.dataProperties(pixelSize(format, type), size)).xy().product();
const std::size_t stride = std::get<1>(storage.dataProperties(pixelFormatSize(format, type), size)).xy().product();
for(Int i = 0; i != size.z(); ++i)
(this->*original)(level, {offset.xy(), offset.z() + i}, {size.xy(), 1}, format, type, static_cast<const char*>(data) + stride*i, storage);

2
src/Magnum/GL/BufferImage.cpp
Unescape View File

@ -64,7 +64,7 @@ template<UnsignedInt dimensions> BufferImage<dimensions>& BufferImage<dimensions
return *this;
}
template<UnsignedInt dimensions> UnsignedInt BufferImage<dimensions>::pixelSize() const { return GL::pixelSize(_format, _type); }
template<UnsignedInt dimensions> UnsignedInt BufferImage<dimensions>::pixelSize() const { return pixelFormatSize(_format, _type); }
template<UnsignedInt dimensions> std::pair<VectorTypeFor<dimensions, std::size_t>, VectorTypeFor<dimensions, std::size_t>> BufferImage<dimensions>::dataProperties() const {
return Magnum::Implementation::imageDataProperties<dimensions>(*this);

9
src/Magnum/GL/BufferImage.h
Unescape View File

@ -61,9 +61,10 @@ and @link GL::PixelType @endlink:
It's also possible to pass the generic @ref Magnum::PixelFormat to it, however
the @ref format() and @ref type() queries will always return the GL-specific
value. On construction, the image internally calculates pixel size
corresponding to given pixel format using either @ref GL::pixelSize() or
@ref Magnum::pixelSize(). This value is needed to check that the passed data
are large enough and also required by most of image manipulation operations.
corresponding to given pixel format using either @ref GL::pixelFormatSize() or
@ref Magnum::pixelFormatSize(). This value is needed to check that the passed
data are large enough and also required by most of image manipulation
operations.
Besides creating and owning the buffer, you can also pass existing buffer to
it, for example to use buffer storage and other advanced functionality. The
@ -275,7 +276,7 @@ template<UnsignedInt dimensions> class BufferImage {
/**
* @brief Size of a pixel in bytes
*
* @see @ref Magnum::pixelSize(), @ref GL::pixelSize()
* @see @ref Magnum::pixelFormatSize(), @ref GL::pixelFormatSize()
*/
UnsignedInt pixelSize() const;

8
src/Magnum/GL/CubeMapTexture.cpp
Unescape View File

@ -640,14 +640,14 @@ void CubeMapTexture::getImageImplementationDSA(const GLint level, const Vector3i
}
void CubeMapTexture::getImageImplementationDSAAmdSliceBySlice(const GLint level, const Vector3i& size, const PixelFormat format, const PixelType type, std::size_t, GLvoid* const data, const PixelStorage& storage) {
auto dataProperties = storage.dataProperties(pixelSize(format, type), size);
auto dataProperties = storage.dataProperties(pixelFormatSize(format, type), size);
const std::size_t stride = dataProperties.second.xy().product();
for(Int i = 0; i != size.z(); ++i)
glGetTextureSubImage(_id, level, 0, 0, i, size.x(), size.y(), 1, GLenum(format), GLenum(type), stride, static_cast<char*>(data) + dataProperties.first.sum() + stride*i);
}
void CubeMapTexture::getImageImplementationSliceBySlice(const GLint level, const Vector3i& size, const PixelFormat format, const PixelType type, std::size_t, GLvoid* const data, const PixelStorage& storage) {
auto dataProperties = storage.dataProperties(pixelSize(format, type), size);
auto dataProperties = storage.dataProperties(pixelFormatSize(format, type), size);
const std::size_t stride = dataProperties.second.xy().product();
for(Int i = 0; i != size.z(); ++i)
getImageImplementationDefault(CubeMapCoordinate(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i), level, size.xy(), format, type, stride, static_cast<char*>(data) + stride*i);
@ -699,14 +699,14 @@ void CubeMapTexture::subImageImplementationDSA(const GLint level, const Vector3i
}
void CubeMapTexture::subImageImplementationDSASliceBySlice(const GLint level, const Vector3i& offset, const Vector3i& size, const PixelFormat format, const PixelType type, const GLvoid* const data, const PixelStorage& storage) {
const std::size_t stride = std::get<1>(storage.dataProperties(pixelSize(format, type), size)).xy().product();
const std::size_t stride = std::get<1>(storage.dataProperties(pixelFormatSize(format, type), size)).xy().product();
for(Int i = 0; i != size.z(); ++i)
subImageImplementationDSA(level, {offset.xy(), offset.z() + i}, {size.xy(), 1}, format, type, static_cast<const char*>(data) + stride*i, storage);
}
#endif
void CubeMapTexture::subImageImplementationSliceBySlice(const GLint level, const Vector3i& offset, const Vector3i& size, const PixelFormat format, const PixelType type, const GLvoid* const data, const PixelStorage& storage) {
const std::size_t stride = std::get<1>(storage.dataProperties(pixelSize(format, type), size)).xy().product();
const std::size_t stride = std::get<1>(storage.dataProperties(pixelFormatSize(format, type), size)).xy().product();
for(Int i = 0; i != size.z(); ++i)
subImageImplementationDefault(CubeMapCoordinate(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i), level, offset.xy(), size.xy(), format, type, static_cast<const char*>(data) + stride*i);
}

4
src/Magnum/GL/PixelFormat.cpp
Unescape View File

@ -122,7 +122,7 @@ TextureFormat textureFormat(const Magnum::PixelFormat format) {
return out;
}
UnsignedInt pixelSize(const PixelFormat format, const PixelType type) {
UnsignedInt pixelFormatSize(const PixelFormat format, const PixelType type) {
std::size_t size = 0;
#ifdef CORRADE_TARGET_GCC
#pragma GCC diagnostic push
@ -252,7 +252,7 @@ UnsignedInt pixelSize(const PixelFormat format, const PixelType type) {
/* Handled above */
case PixelFormat::DepthStencil:
CORRADE_ASSERT_UNREACHABLE("GL::pixelSize(): invalid" << type << "specified for" << format, 0);
CORRADE_ASSERT_UNREACHABLE("GL::pixelFormatSize(): invalid" << type << "specified for" << format, 0);
}
#ifdef CORRADE_TARGET_GCC
#pragma GCC diagnostic pop

18
src/Magnum/GL/PixelFormat.h
Unescape View File

@ -26,7 +26,7 @@
*/
/** @file
* @brief Enum @ref Magnum::GL::PixelFormat, @ref Magnum::GL::PixelType, @ref Magnum::GL::CompressedPixelFormat, function @ref Magnum::GL::hasPixelFormat(), @ref Magnum::GL::pixelFormat(), @ref Magnum::GL::pixelType(), @ref Magnum::GL::pixelSize(), @ref Magnum::GL::hasCompressedPixelFormat(), @ref Magnum::GL::compressedPixelFormat()
* @brief Enum @ref Magnum::GL::PixelFormat, @ref Magnum::GL::PixelType, @ref Magnum::GL::CompressedPixelFormat, function @ref Magnum::GL::hasPixelFormat(), @ref Magnum::GL::pixelFormat(), @ref Magnum::GL::pixelType(), @ref Magnum::GL::pixelFormatSize(), @ref Magnum::GL::hasCompressedPixelFormat(), @ref Magnum::GL::compressedPixelFormat()
*/
#include <Corrade/Utility/Assert.h>
@ -676,7 +676,7 @@ to query availability of given format.
MAGNUM_GL_EXPORT PixelFormat pixelFormat(Magnum::PixelFormat format);
/**
@brief Convert a generic pixel type to OpenGL pixel type
@brief Convert a generic pixel format to OpenGL pixel type
In case @ref isPixelFormatImplementationSpecific() returns @cpp false @ce for
@p format, maps it to a corresponding OpenGL pixel type. In case
@ -694,9 +694,19 @@ MAGNUM_GL_EXPORT PixelType pixelType(Magnum::PixelFormat format, UnsignedInt ext
/**
@brief Size of a pixel for given format/type combination in bytes
@see @ref Magnum::pixelSize(), @ref PixelStorage::dataProperties()
@see @ref Magnum::pixelFormatSize(), @ref PixelStorage::dataProperties()
*/
MAGNUM_GL_EXPORT UnsignedInt pixelSize(PixelFormat format, PixelType type);
MAGNUM_GL_EXPORT UnsignedInt pixelFormatSize(PixelFormat format, PixelType type);
#ifdef MAGNUM_BUILD_DEPRECATED
/**
* @brief @copybrief pixelFormatSize()
* @m_deprecated_since_latest Use @ref pixelFormatSize() instead.
*/
CORRADE_DEPRECATED("use pixelFormatSize() instead") inline UnsignedInt pixelSize(PixelFormat format, PixelType type) {
return pixelFormatSize(format, type);
}
#endif
/** @debugoperatorenum{PixelFormat} */
MAGNUM_GL_EXPORT Debug& operator<<(Debug& debug, PixelFormat value);

18
src/Magnum/GL/Test/PixelFormatTest.cpp
Unescape View File

@ -337,17 +337,17 @@ void PixelFormatTest::mapTextureFormatInvalid() {
void PixelFormatTest::size() {
#ifndef MAGNUM_TARGET_GLES
CORRADE_COMPARE(pixelSize(PixelFormat::RGB, PixelType::UnsignedByte332), 1);
CORRADE_COMPARE(pixelFormatSize(PixelFormat::RGB, PixelType::UnsignedByte332), 1);
#endif
#ifndef MAGNUM_TARGET_WEBGL
CORRADE_COMPARE(pixelSize(PixelFormat::StencilIndex, PixelType::UnsignedByte), 1);
CORRADE_COMPARE(pixelFormatSize(PixelFormat::StencilIndex, PixelType::UnsignedByte), 1);
#endif
CORRADE_COMPARE(pixelSize(PixelFormat::DepthComponent, PixelType::UnsignedShort), 2);
CORRADE_COMPARE(pixelSize(PixelFormat::RGBA, PixelType::UnsignedShort4444), 2);
CORRADE_COMPARE(pixelSize(PixelFormat::DepthStencil, PixelType::UnsignedInt248), 4);
CORRADE_COMPARE(pixelSize(PixelFormat::RGBA, PixelType::UnsignedInt), 4*4);
CORRADE_COMPARE(pixelFormatSize(PixelFormat::DepthComponent, PixelType::UnsignedShort), 2);
CORRADE_COMPARE(pixelFormatSize(PixelFormat::RGBA, PixelType::UnsignedShort4444), 2);
CORRADE_COMPARE(pixelFormatSize(PixelFormat::DepthStencil, PixelType::UnsignedInt248), 4);
CORRADE_COMPARE(pixelFormatSize(PixelFormat::RGBA, PixelType::UnsignedInt), 4*4);
#ifndef MAGNUM_TARGET_GLES2
CORRADE_COMPARE(pixelSize(PixelFormat::DepthStencil, PixelType::Float32UnsignedInt248Rev), 8);
CORRADE_COMPARE(pixelFormatSize(PixelFormat::DepthStencil, PixelType::Float32UnsignedInt248Rev), 8);
#endif
}
@ -358,8 +358,8 @@ void PixelFormatTest::sizeInvalid() {
std::ostringstream out;
Error redirectError{&out};
pixelSize(PixelFormat::DepthStencil, PixelType::Float);
CORRADE_COMPARE(out.str(), "GL::pixelSize(): invalid GL::PixelType::Float specified for GL::PixelFormat::DepthStencil\n");
pixelFormatSize(PixelFormat::DepthStencil, PixelType::Float);
CORRADE_COMPARE(out.str(), "GL::pixelFormatSize(): invalid GL::PixelType::Float specified for GL::PixelFormat::DepthStencil\n");
}
void PixelFormatTest::mapCompressedFormatTextureFormat() {

4
src/Magnum/Image.cpp
Unescape View File

@ -31,7 +31,7 @@
namespace Magnum {
template<UnsignedInt dimensions> Image<dimensions>::Image(const PixelStorage storage, const PixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data) noexcept: Image{storage, format, {}, Magnum::pixelSize(format), size, std::move(data)} {}
template<UnsignedInt dimensions> Image<dimensions>::Image(const PixelStorage storage, const PixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data) noexcept: Image{storage, format, {}, pixelFormatSize(format), size, std::move(data)} {}
template<UnsignedInt dimensions> Image<dimensions>::Image(const PixelStorage storage, const UnsignedInt format, const UnsignedInt formatExtra, const UnsignedInt pixelSize, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data) noexcept: Image{storage, pixelFormatWrap(format), formatExtra, pixelSize, size, std::move(data)} {}
@ -39,7 +39,7 @@ template<UnsignedInt dimensions> Image<dimensions>::Image(const PixelStorage sto
CORRADE_ASSERT(Implementation::imageDataSize(*this) <= _data.size(), "Image: data too small, got" << _data.size() << "but expected at least" << Implementation::imageDataSize(*this) << "bytes", );
}
template<UnsignedInt dimensions> Image<dimensions>::Image(const PixelStorage storage, const PixelFormat format) noexcept: Image{storage, format, {}, Magnum::pixelSize(format)} {}
template<UnsignedInt dimensions> Image<dimensions>::Image(const PixelStorage storage, const PixelFormat format) noexcept: Image{storage, format, {}, pixelFormatSize(format)} {}
template<UnsignedInt dimensions> Image<dimensions>::Image(const PixelStorage storage, const UnsignedInt format, const UnsignedInt formatExtra, const UnsignedInt pixelSize) noexcept: Image{storage, pixelFormatWrap(format), formatExtra, pixelSize} {}

38
src/Magnum/Image.h
Unescape View File

@ -67,8 +67,8 @@ with storing image size and one of the generic @ref PixelFormat values:
@snippet Magnum.cpp Image-usage
On construction, the image internally calculates pixel size corresponding to
given pixel format using @ref pixelSize(). This value is needed to check that
the passed data array is large enough and is also required by most image
given pixel format using @ref pixelFormatSize(). This value is needed to check
that the passed data array is large enough and is also required by most image
manipulation operations.
It's also possible to create just an image placeholder, storing only the image
@ -173,7 +173,7 @@ template<UnsignedInt dimensions> class Image {
*
* Unlike with @ref Image(PixelStorage, PixelFormat, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&),
* where pixel size is calculated automatically using
* @ref pixelSize(PixelFormat), this allows you to specify an
* @ref pixelFormatSize(), this allows you to specify an
* implementation-specific pixel format and pixel size directly. Uses
* @ref pixelFormatWrap() internally to wrap @p format in
* @ref PixelFormat.
@ -198,10 +198,10 @@ template<UnsignedInt dimensions> class Image {
* @param pixelSize Size of a pixel in given format, in bytes
*
* Unlike with @ref Image(PixelStorage, PixelFormat), where pixel size
* is calculated automatically using @ref pixelSize(PixelFormat), this
* is calculated automatically using @ref pixelFormatSize(), this
* allows you to specify an implementation-specific pixel format and
* pixel size directly. Uses @ref pixelFormatWrap() internally to
* wrap @p format in @ref PixelFormat.
* pixel size directly. Uses @ref pixelFormatWrap() internally to wrap
* @p format in @ref PixelFormat.
*/
explicit Image(PixelStorage storage, UnsignedInt format, UnsignedInt formatExtra, UnsignedInt pixelSize) noexcept;
@ -220,8 +220,8 @@ template<UnsignedInt dimensions> class Image {
* @param size Image size
* @param data Image data
*
* Uses ADL to find a corresponding @cpp pixelSize(T, U) @ce overload,
* then calls @ref Image(PixelStorage, UnsignedInt, UnsignedInt, UnsignedInt, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&)
* Uses ADL to find a corresponding @cpp pixelFormatSize(T, U) @ce
* overload, then calls @ref Image(PixelStorage, UnsignedInt, UnsignedInt, UnsignedInt, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&)
* with calculated pixel size.
*/
template<class T, class U> explicit Image(PixelStorage storage, T format, U formatExtra, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data) noexcept;
@ -233,8 +233,8 @@ template<UnsignedInt dimensions> class Image {
* @param size Image size
* @param data Image data
*
* Uses ADL to find a corresponding @cpp pixelSize(T) @ce overload,
* then calls @ref Image(PixelStorage, UnsignedInt, UnsignedInt, UnsignedInt, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&)
* Uses ADL to find a corresponding @cpp pixelFormatSize(T) @ce
* overload, then calls @ref Image(PixelStorage, UnsignedInt, UnsignedInt, UnsignedInt, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&)
* with calculated pixel size and @p formatExtra set to @cpp 0 @ce.
*/
template<class T> explicit Image(PixelStorage storage, T format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data) noexcept;
@ -268,8 +268,8 @@ template<UnsignedInt dimensions> class Image {
* @param format Format of pixel data
* @param formatExtra Additional pixel format specifier
*
* Uses ADL to find a corresponding @cpp pixelSize(T, U) @ce overload,
* then calls @ref Image(PixelStorage, UnsignedInt, UnsignedInt, UnsignedInt)
* Uses ADL to find a corresponding @cpp pixelFormatSize(T, U) @ce
* overload, then calls @ref Image(PixelStorage, UnsignedInt, UnsignedInt, UnsignedInt)
* with calculated pixel size.
*/
template<class T, class U> /*implicit*/ Image(PixelStorage storage, T format, U formatExtra) noexcept;
@ -289,8 +289,8 @@ template<UnsignedInt dimensions> class Image {
* @param storage Storage of pixel data
* @param format Format of pixel data
*
* Uses ADL to find a corresponding @cpp pixelSize(T) @ce overload,
* then calls @ref Image(PixelStorage, UnsignedInt, UnsignedInt, UnsignedInt)
* Uses ADL to find a corresponding @cpp pixelFormatSize(T) @ce
* overload, then calls @ref Image(PixelStorage, UnsignedInt, UnsignedInt, UnsignedInt)
* with calculated pixel size and @p formatExtra set to @cpp 0 @ce.
*/
template<class T> /*implicit*/ Image(PixelStorage storage, T format) noexcept;
@ -359,7 +359,7 @@ template<UnsignedInt dimensions> class Image {
/**
* @brief Size of a pixel in bytes
*
* @see @ref pixelSize(PixelFormat)
* @see @ref pixelFormatSize()
*/
UnsignedInt pixelSize() const { return _pixelSize; }
@ -708,22 +708,22 @@ typedef CompressedImage<2> CompressedImage2D;
/** @brief Three-dimensional compressed image */
typedef CompressedImage<3> CompressedImage3D;
template<UnsignedInt dimensions> template<class T, class U> inline Image<dimensions>::Image(const PixelStorage storage, const T format, const U formatExtra, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data) noexcept: Image{storage, UnsignedInt(format), UnsignedInt(formatExtra), Implementation::pixelSizeAdl(format, formatExtra), size, std::move(data)} {
template<UnsignedInt dimensions> template<class T, class U> inline Image<dimensions>::Image(const PixelStorage storage, const T format, const U formatExtra, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data) noexcept: Image{storage, UnsignedInt(format), UnsignedInt(formatExtra), Implementation::pixelFormatSizeAdl(format, formatExtra), size, std::move(data)} {
static_assert(sizeof(T) <= 4 && sizeof(U) <= 4,
"format types larger than 32bits are not supported");
}
template<UnsignedInt dimensions> template<class T> inline Image<dimensions>::Image(const PixelStorage storage, const T format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data) noexcept: Image{storage, UnsignedInt(format), {}, Implementation::pixelSizeAdl(format), size, std::move(data)} {
template<UnsignedInt dimensions> template<class T> inline Image<dimensions>::Image(const PixelStorage storage, const T format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data) noexcept: Image{storage, UnsignedInt(format), {}, Implementation::pixelFormatSizeAdl(format), size, std::move(data)} {
static_assert(sizeof(T) <= 4,
"format types larger than 32bits are not supported");
}
template<UnsignedInt dimensions> template<class T, class U> inline Image<dimensions>::Image(const PixelStorage storage, const T format, const U formatExtra) noexcept: Image{storage, UnsignedInt(format), UnsignedInt(formatExtra), Implementation::pixelSizeAdl(format, formatExtra)} {
template<UnsignedInt dimensions> template<class T, class U> inline Image<dimensions>::Image(const PixelStorage storage, const T format, const U formatExtra) noexcept: Image{storage, UnsignedInt(format), UnsignedInt(formatExtra), Implementation::pixelFormatSizeAdl(format, formatExtra)} {
static_assert(sizeof(T) <= 4 && sizeof(U) <= 4,
"format types larger than 32bits are not supported");
}
template<UnsignedInt dimensions> template<class T> inline Image<dimensions>::Image(const PixelStorage storage, const T format) noexcept: Image{storage, UnsignedInt(format), {}, Implementation::pixelSizeAdl(format)} {
template<UnsignedInt dimensions> template<class T> inline Image<dimensions>::Image(const PixelStorage storage, const T format) noexcept: Image{storage, UnsignedInt(format), {}, Implementation::pixelFormatSizeAdl(format)} {
static_assert(sizeof(T) <= 4,
"format types larger than 32bits are not supported");
}

4
src/Magnum/ImageView.cpp
Unescape View File

@ -30,7 +30,7 @@
namespace Magnum {
template<UnsignedInt dimensions, class T> ImageView<dimensions, T>::ImageView(const PixelStorage storage, const PixelFormat format, const VectorTypeFor<dimensions, Int>& size, const Containers::ArrayView<ErasedType> data) noexcept: ImageView{storage, format, {}, Magnum::pixelSize(format), size, data} {}
template<UnsignedInt dimensions, class T> ImageView<dimensions, T>::ImageView(const PixelStorage storage, const PixelFormat format, const VectorTypeFor<dimensions, Int>& size, const Containers::ArrayView<ErasedType> data) noexcept: ImageView{storage, format, {}, pixelFormatSize(format), size, data} {}
template<UnsignedInt dimensions, class T> ImageView<dimensions, T>::ImageView(const PixelStorage storage, const UnsignedInt format, const UnsignedInt formatExtra, const UnsignedInt pixelSize, const VectorTypeFor<dimensions, Int>& size, const Containers::ArrayView<ErasedType> data) noexcept: ImageView{storage, pixelFormatWrap(format), formatExtra, pixelSize, size, data} {}
@ -46,7 +46,7 @@ template<UnsignedInt dimensions, class T> ImageView<dimensions, T>::ImageView(co
#endif
}
template<UnsignedInt dimensions, class T> ImageView<dimensions, T>::ImageView(const PixelStorage storage, const PixelFormat format, const VectorTypeFor<dimensions, Int>& size) noexcept: ImageView{storage, format, {}, Magnum::pixelSize(format), size} {}
template<UnsignedInt dimensions, class T> ImageView<dimensions, T>::ImageView(const PixelStorage storage, const PixelFormat format, const VectorTypeFor<dimensions, Int>& size) noexcept: ImageView{storage, format, {}, pixelFormatSize(format), size} {}
template<UnsignedInt dimensions, class T> ImageView<dimensions, T>::ImageView(const PixelStorage storage, const UnsignedInt format, const UnsignedInt formatExtra, const UnsignedInt pixelSize, const VectorTypeFor<dimensions, Int>& size) noexcept: ImageView{storage, pixelFormatWrap(format), formatExtra, pixelSize, size} {}

52
src/Magnum/ImageView.h
Unescape View File

@ -72,9 +72,9 @@ describe its layout, with pixel format being one of the values from the generic
@snippet Magnum.cpp ImageView-usage
On construction, the image view internally calculates pixel size corresponding
to given pixel format using @ref pixelSize(). This value is needed to check
that the passed data array is large enough and is also required by most image
manipulation operations.
to given pixel format using @ref pixelFormatSize(). This value is needed to
check that the passed data array is large enough and is also required by most
image manipulation operations.
It's also possible to create an empty view and assign the memory later. That is
useful for example in case of multi-buffered video streaming, where each frame
@ -114,9 +114,9 @@ the @ref GL::PixelFormat and @ref GL::PixelType pair:
@snippet Magnum.cpp ImageView-usage-gl
In such cases, pixel size is calculated using either @cpp pixelSize(T, U) @ce
or @cpp pixelSize(T) @ce that is found using
[ADL](https://en.wikipedia.org/wiki/Argument-dependent_name_lookup), with
In such cases, pixel size is calculated using either
@cpp pixelFormatSize(T, U) @ce or @cpp pixelFormatSize(T) @ce that is found
using [ADL](https://en.wikipedia.org/wiki/Argument-dependent_name_lookup), with
@cpp T @ce and @cpp U @ce corresponding to types of passed arguments. The
implementation-specific format is wrapped in @ref PixelFormat using
@ref pixelFormatWrap() and @ref format() returns the wrapped value. In order to
@ -127,11 +127,11 @@ value is stored verbatim in @ref formatExtra():
@snippet Magnum.cpp ImageView-usage-gl-extract
As a final fallback, types for which the @cpp pixelSize() @ce overload is not
available can be specified directly together with pixel size. In particular,
pixel size of @cpp 0 @ce will cause the image to be treated as fully opaque
data, disabling all slicing operations. The following shows a image view using
Metal-specific format identifier:
As a final fallback, types for which the @cpp pixelFormatSize() @ce overload is
not available can be specified directly together with pixel size. In
particular, pixel size of @cpp 0 @ce will cause the image to be treated as
fully opaque data, disabling all slicing operations. The following shows a
image view using Metal-specific format identifier:
@snippet Magnum.cpp ImageView-usage-metal
@ -220,7 +220,7 @@ template<UnsignedInt dimensions, class T> class ImageView {
*
* Unlike with @ref ImageView(PixelStorage, PixelFormat, const VectorTypeFor<dimensions, Int>&, Containers::ArrayView<ErasedType>),
* where pixel size is calculated automatically using
* @ref pixelSize(PixelFormat), this allows you to specify an
* @ref pixelFormatSize(), this allows you to specify an
* implementation-specific pixel format and pixel size directly. Uses
* @ref pixelFormatWrap() internally to wrap @p format in
* @ref PixelFormat.
@ -247,7 +247,7 @@ template<UnsignedInt dimensions, class T> class ImageView {
*
* Unlike with @ref ImageView(PixelStorage, PixelFormat, const VectorTypeFor<dimensions, Int>&),
* where pixel size is calculated automatically using
* @ref pixelSize(PixelFormat), this allows you to specify an
* @ref pixelFormatSize(), this allows you to specify an
* implementation-specific pixel format and pixel size directly. Uses
* @ref pixelFormatWrap() internally to wrap @p format in
* @ref PixelFormat.
@ -272,8 +272,8 @@ template<UnsignedInt dimensions, class T> class ImageView {
* @param size Image size
* @param data Image data
*
* Uses ADL to find a corresponding @cpp pixelSize(T, U) @ce overload,
* then calls @ref ImageView(PixelStorage, UnsignedInt, UnsignedInt, UnsignedInt, const VectorTypeFor<dimensions, Int>&, Containers::ArrayView<ErasedType>)
* Uses ADL to find a corresponding @cpp pixelFormatSize(T, U) @ce
* overload, then calls @ref ImageView(PixelStorage, UnsignedInt, UnsignedInt, UnsignedInt, const VectorTypeFor<dimensions, Int>&, Containers::ArrayView<ErasedType>)
* with calculated pixel size.
*/
template<class U, class V> explicit ImageView(PixelStorage storage, U format, V formatExtra, const VectorTypeFor<dimensions, Int>& size, Containers::ArrayView<ErasedType> data) noexcept;
@ -285,8 +285,8 @@ template<UnsignedInt dimensions, class T> class ImageView {
* @param size Image size
* @param data Image data
*
* Uses ADL to find a corresponding @cpp pixelSize(T) @ce overload,
* then calls @ref ImageView(PixelStorage, UnsignedInt, UnsignedInt, UnsignedInt, const VectorTypeFor<dimensions, Int>&, Containers::ArrayView<ErasedType>)
* Uses ADL to find a corresponding @cpp pixelFormatSize(T) @ce
* overload, then calls @ref ImageView(PixelStorage, UnsignedInt, UnsignedInt, UnsignedInt, const VectorTypeFor<dimensions, Int>&, Containers::ArrayView<ErasedType>)
* with calculated pixel size and @p formatExtra set to @cpp 0 @ce.
*/
template<class U> explicit ImageView(PixelStorage storage, U format, const VectorTypeFor<dimensions, Int>& size, Containers::ArrayView<ErasedType> data) noexcept;
@ -321,8 +321,8 @@ template<UnsignedInt dimensions, class T> class ImageView {
* @param formatExtra Additional pixel format specifier
* @param size Image size
*
* Uses ADL to find a corresponding @cpp pixelSize(T, U) @ce overload,
* then calls @ref ImageView(PixelStorage, UnsignedInt, UnsignedInt, UnsignedInt, const VectorTypeFor<dimensions, Int>&)
* Uses ADL to find a corresponding @cpp pixelFormatSize(T, U) @ce
* overload, then calls @ref ImageView(PixelStorage, UnsignedInt, UnsignedInt, UnsignedInt, const VectorTypeFor<dimensions, Int>&)
* with calculated pixel size.
*
* Data pointer is set to @cpp nullptr @ce, call @ref setData() to
@ -336,8 +336,8 @@ template<UnsignedInt dimensions, class T> class ImageView {
* @param format Format of pixel data
* @param size Image size
*
* Uses ADL to find a corresponding @cpp pixelSize(T) @ce overload,
* then calls @ref ImageView(PixelStorage, UnsignedInt, UnsignedInt, UnsignedInt, const VectorTypeFor<dimensions, Int>&)
* Uses ADL to find a corresponding @cpp pixelFormatSize(T) @ce
* overload, then calls @ref ImageView(PixelStorage, UnsignedInt, UnsignedInt, UnsignedInt, const VectorTypeFor<dimensions, Int>&)
* with calculated pixel size and @p formatExtra set to @cpp 0 @ce.
*
* Data pointer is set to @cpp nullptr @ce, call @ref setData() to
@ -405,7 +405,7 @@ template<UnsignedInt dimensions, class T> class ImageView {
/**
* @brief Size of a pixel in bytes
*
* @see @ref pixelSize(PixelFormat)
* @see @ref pixelFormatSize()
*/
UnsignedInt pixelSize() const { return _pixelSize; }
@ -899,22 +899,22 @@ typedef BasicMutableCompressedImageView<2> MutableCompressedImageView2D;
*/
typedef BasicMutableCompressedImageView<3> MutableCompressedImageView3D;
template<UnsignedInt dimensions, class T> template<class U, class V> inline ImageView<dimensions, T>::ImageView(const PixelStorage storage, const U format, const V formatExtra, const VectorTypeFor<dimensions, Int>& size, const Containers::ArrayView<ErasedType> data) noexcept: ImageView{storage, UnsignedInt(format), UnsignedInt(formatExtra), Implementation::pixelSizeAdl(format, formatExtra), size, data} {
template<UnsignedInt dimensions, class T> template<class U, class V> inline ImageView<dimensions, T>::ImageView(const PixelStorage storage, const U format, const V formatExtra, const VectorTypeFor<dimensions, Int>& size, const Containers::ArrayView<ErasedType> data) noexcept: ImageView{storage, UnsignedInt(format), UnsignedInt(formatExtra), Implementation::pixelFormatSizeAdl(format, formatExtra), size, data} {
static_assert(sizeof(T) <= 4 && sizeof(U) <= 4,
"format types larger than 32bits are not supported");
}
template<UnsignedInt dimensions, class T> template<class U> inline ImageView<dimensions, T>::ImageView(const PixelStorage storage, const U format, const VectorTypeFor<dimensions, Int>& size, const Containers::ArrayView<ErasedType> data) noexcept: ImageView{storage, UnsignedInt(format), {}, Implementation::pixelSizeAdl(format), size, data} {
template<UnsignedInt dimensions, class T> template<class U> inline ImageView<dimensions, T>::ImageView(const PixelStorage storage, const U format, const VectorTypeFor<dimensions, Int>& size, const Containers::ArrayView<ErasedType> data) noexcept: ImageView{storage, UnsignedInt(format), {}, Implementation::pixelFormatSizeAdl(format), size, data} {
static_assert(sizeof(U) <= 4,
"format types larger than 32bits are not supported");
}
template<UnsignedInt dimensions, class T> template<class U, class V> inline ImageView<dimensions, T>::ImageView(const PixelStorage storage, const U format, const V formatExtra, const VectorTypeFor<dimensions, Int>& size) noexcept: ImageView{storage, UnsignedInt(format), UnsignedInt(formatExtra), Implementation::pixelSizeAdl(format, formatExtra), size} {
template<UnsignedInt dimensions, class T> template<class U, class V> inline ImageView<dimensions, T>::ImageView(const PixelStorage storage, const U format, const V formatExtra, const VectorTypeFor<dimensions, Int>& size) noexcept: ImageView{storage, UnsignedInt(format), UnsignedInt(formatExtra), Implementation::pixelFormatSizeAdl(format, formatExtra), size} {
static_assert(sizeof(U) <= 4 && sizeof(U) <= 4,
"format types larger than 32bits are not supported");
}
template<UnsignedInt dimensions, class T> template<class U> inline ImageView<dimensions, T>::ImageView(const PixelStorage storage, const U format, const VectorTypeFor<dimensions, Int>& size) noexcept: ImageView{storage, UnsignedInt(format), {}, Implementation::pixelSizeAdl(format), size} {
template<UnsignedInt dimensions, class T> template<class U> inline ImageView<dimensions, T>::ImageView(const PixelStorage storage, const U format, const VectorTypeFor<dimensions, Int>& size) noexcept: ImageView{storage, UnsignedInt(format), {}, Implementation::pixelFormatSizeAdl(format), size} {
static_assert(sizeof(U) <= 4,
"format types larger than 32bits are not supported");
}

24
src/Magnum/PixelFormat.cpp
Unescape View File

@ -34,9 +34,9 @@
namespace Magnum {
UnsignedInt pixelSize(const PixelFormat format) {
UnsignedInt pixelFormatSize(const PixelFormat format) {
CORRADE_ASSERT(!isPixelFormatImplementationSpecific(format),
"pixelSize(): can't determine size of an implementation-specific format" << reinterpret_cast<void*>(pixelFormatUnwrap(format)), {});
"pixelFormatSize(): can't determine size of an implementation-specific format" << reinterpret_cast<void*>(pixelFormatUnwrap(format)), {});
#ifdef CORRADE_TARGET_GCC
#pragma GCC diagnostic push
@ -115,7 +115,7 @@ UnsignedInt pixelSize(const PixelFormat format) {
#pragma GCC diagnostic pop
#endif
CORRADE_ASSERT_UNREACHABLE("pixelSize(): invalid format" << format, {});
CORRADE_ASSERT_UNREACHABLE("pixelFormatSize(): invalid format" << format, {});
}
namespace {
@ -176,12 +176,12 @@ constexpr UnsignedShort CompressedBlockData[] {
}
Vector3i compressedBlockSize(const CompressedPixelFormat format) {
Vector3i compressedPixelFormatBlockSize(const CompressedPixelFormat format) {
CORRADE_ASSERT(!(UnsignedInt(format) & (1 << 31)),
"compressedBlockSize(): can't determine size of an implementation-specific format" << reinterpret_cast<void*>(compressedPixelFormatUnwrap(format)), {});
"compressedPixelFormatBlockSize(): can't determine size of an implementation-specific format" << reinterpret_cast<void*>(compressedPixelFormatUnwrap(format)), {});
CORRADE_ASSERT(UnsignedInt(format) - 1 < Containers::arraySize(CompressedBlockData),
"compressedBlockSize(): invalid format" << format, {});
"compressedPixelFormatBlockSize(): invalid format" << format, {});
const UnsignedInt data = CompressedBlockData[UnsignedInt(format) - 1];
return {
(Int(data >> 12) & 0xf) + 1,
@ -190,12 +190,18 @@ Vector3i compressedBlockSize(const CompressedPixelFormat format) {
};
}
UnsignedInt compressedBlockDataSize(const CompressedPixelFormat format) {
#ifdef MAGNUM_BUILD_DEPRECATED
Vector3i compressedBlockSize(const CompressedPixelFormat format) {
return compressedPixelFormatBlockSize(format);
}
#endif
UnsignedInt compressedPixelFormatBlockDataSize(const CompressedPixelFormat format) {
CORRADE_ASSERT(!(UnsignedInt(format) & (1 << 31)),
"compressedBlockDataSize(): can't determine size of an implementation-specific format" << reinterpret_cast<void*>(compressedPixelFormatUnwrap(format)), {});
"compressedPixelFormatBlockDataSize(): can't determine size of an implementation-specific format" << reinterpret_cast<void*>(compressedPixelFormatUnwrap(format)), {});
CORRADE_ASSERT(UnsignedInt(format) - 1 < Containers::arraySize(CompressedBlockData),
"compressedBlockDataSize(): invalid format" << format, {});
"compressedPixelFormatBlockDataSize(): invalid format" << format, {});
return (CompressedBlockData[UnsignedInt(format) - 1] & 0xf) + 1;
}

68
src/Magnum/PixelFormat.h
Unescape View File

@ -26,7 +26,7 @@
*/
/** @file
* @brief Enum @ref Magnum::PixelFormat, @ref Magnum::CompressedPixelFormat, function @ref Magnum::pixelSize(), @ref Magnum::isPixelFormatImplementationSpecific(), @ref Magnum::pixelFormatWrap(), @ref Magnum::pixelFormatUnwrap(), @ref Magnum::isCompressedPixelFormatImplementationSpecific(), @ref Magnum::compressedPixelFormatWrap(), @ref Magnum::compressedPixelFormatUnwrap()
* @brief Enum @ref Magnum::PixelFormat, @ref Magnum::CompressedPixelFormat, function @ref Magnum::pixelFormatSize(), @ref Magnum::isPixelFormatImplementationSpecific(), @ref Magnum::pixelFormatWrap(), @ref Magnum::pixelFormatUnwrap(), @ref Magnum::compressedPixelFormatBlockSize(), @ref Magnum::compressedPixelFormatBlockDataSize(), @ref Magnum::isCompressedPixelFormatImplementationSpecific(), @ref Magnum::compressedPixelFormatWrap(), @ref Magnum::compressedPixelFormatUnwrap()
*/
#include <Corrade/Utility/Assert.h>
@ -35,6 +35,10 @@
#include "Magnum/Magnum.h"
#include "Magnum/visibility.h"
#ifdef MAGNUM_BUILD_DEPRECATED
#include <Corrade/Utility/Macros.h>
#endif
namespace Magnum {
/**
@ -61,8 +65,8 @@ For D3D, corresponds to @m_class{m-doc-external} [DXGI_FORMAT](https://docs.micr
and import is provided by the @ref Trade::DdsImporter "DdsImporter" plugin; for
Metal, corresponds to @m_class{m-doc-external} [MTLPixelFormat](https://developer.apple.com/documentation/metal/mtlpixelformat?language=objc).
See documentation of each value for more information about the mapping.
@see @ref pixelSize(), @ref CompressedPixelFormat, @ref Image, @ref ImageView,
@ref VertexFormat
@see @ref pixelFormatSize(), @ref CompressedPixelFormat, @ref Image,
@ref ImageView, @ref VertexFormat
*/
enum class PixelFormat: UnsignedInt {
/* Zero reserved for an invalid format (but not being a named value) */
@ -768,12 +772,23 @@ enum class PixelFormat: UnsignedInt {
};
/**
@brief Size of a pixel
@brief Pixel format size
@m_since_latest
Expects that the pixel format is *not* implementation-specific.
@see @ref isPixelFormatImplementationSpecific(), @ref GL::pixelSize()
@see @ref isPixelFormatImplementationSpecific(), @ref GL::pixelFormatSize()
*/
MAGNUM_EXPORT UnsignedInt pixelSize(PixelFormat format);
MAGNUM_EXPORT UnsignedInt pixelFormatSize(PixelFormat format);
#ifdef MAGNUM_BUILD_DEPRECATED
/**
* @brief @copybrief pixelFormatSize()
* @m_deprecated_since_latest Use @ref pixelFormatSize() instead.
*/
MAGNUM_EXPORT CORRADE_DEPRECATED("use pixelFormatSize() instead") inline UnsignedInt pixelSize(PixelFormat format) {
return pixelFormatSize(format);
}
#endif
/** @debugoperatorenum{PixelFormat} */
MAGNUM_EXPORT Debug& operator<<(Debug& debug, PixelFormat value);
@ -844,8 +859,9 @@ For D3D, corresponds to @m_class{m-doc-external} [DXGI_FORMAT](https://docs.micr
and import is provided by the @ref Trade::DdsImporter "DdsImporter" plugin; for
Metal, corresponds to @m_class{m-doc-external} [MTLPixelFormat](https://developer.apple.com/documentation/metal/mtlpixelformat?language=objc).
See documentation of each value for more information about the mapping.
@see @ref compressedBlockSize(), @ref compressedBlockDataSize(),
@ref PixelFormat, @ref CompressedImage, @ref CompressedImageView
@see @ref compressedPixelFormatBlockSize(),
@ref compressedPixelFormatBlockDataSize(), @ref PixelFormat,
@ref CompressedImage, @ref CompressedImageView
*/
enum class CompressedPixelFormat: UnsignedInt {
/* Zero reserved for an invalid format (but not being a named value) */
@ -2322,26 +2338,46 @@ enum class CompressedPixelFormat: UnsignedInt {
};
/**
@brief Compressed block size
@m_since{2019,10}
@brief Compressed pixel format block size
@m_since_latest
For 2D formats the Z dimension is always 1. Expects that the pixel format is
* *not* implementation-specific.
@see @ref compressedBlockDataSize(),
@see @ref compressedPixelFormatBlockDataSize(),
@ref isCompressedPixelFormatImplementationSpecific()
*/
MAGNUM_EXPORT Vector3i compressedBlockSize(CompressedPixelFormat format);
MAGNUM_EXPORT Vector3i compressedPixelFormatBlockSize(CompressedPixelFormat format);
#ifdef MAGNUM_BUILD_DEPRECATED
/**
* @brief @copybrief compressedPixelFormatBlockSize()
* @m_deprecated_since_latest Use @ref compressedPixelFormatBlockSize()
* instead.
*/
MAGNUM_EXPORT CORRADE_DEPRECATED("use compressedPixelFormatBlockSize() instead") Vector3i compressedBlockSize(CompressedPixelFormat format);
#endif
/**
@brief Compressed block data size
@m_since{2019,10}
@brief Compressed pixel format block data size
@m_since_latest
Byte size of each compressed block. Expects that the pixel format is *not*
implementation-specific.
@see @ref compressedBlockSize(),
@see @ref compressedPixelFormatBlockSize(),
@ref isCompressedPixelFormatImplementationSpecific()
*/
MAGNUM_EXPORT UnsignedInt compressedBlockDataSize(CompressedPixelFormat format);
MAGNUM_EXPORT UnsignedInt compressedPixelFormatBlockDataSize(CompressedPixelFormat format);
#ifdef MAGNUM_BUILD_DEPRECATED
/**
* @brief @copybrief compressedPixelFormatBlockDataSize()
* @m_deprecated_since_latest Use @ref compressedPixelFormatBlockDataSize()
* instead.
*/
CORRADE_DEPRECATED("use compressedPixelFormatBlockDataSize() instead") inline UnsignedInt compressedBlockDataSize(CompressedPixelFormat format) {
return compressedPixelFormatBlockDataSize(format);
}
#endif
/** @debugoperatorenum{CompressedPixelFormat} */
MAGNUM_EXPORT Debug& operator<<(Debug& debug, CompressedPixelFormat value);

14
src/Magnum/PixelStorage.h
Unescape View File

@ -128,7 +128,7 @@ class MAGNUM_EXPORT PixelStorage {
* and given @p pixelSize. The offset reflects the @ref skip()
* parameter. Sum of the byte offset vector gives the byte offset of
* first pixel in the data array.
* @see @ref GL::pixelSize()
* @see @ref pixelFormatSize(), @ref GL::pixelFormatSize()
*/
std::pair<Math::Vector3<std::size_t>, Math::Vector3<std::size_t>> dataProperties(std::size_t pixelSize, const Vector3i& size) const;
@ -185,7 +185,7 @@ class MAGNUM_EXPORT CompressedPixelStorage: public PixelStorage {
* If set to @cpp 0 @ce for given dimension, size information from
* particular compressed format is used. Default is @cpp 0 @ce in all
* dimensions.
* @see @ref Magnum::compressedBlockSize()
* @see @ref Magnum::compressedPixelFormatBlockSize()
*/
CompressedPixelStorage& setCompressedBlockSize(const Vector3i& size) {
_blockSize = size;
@ -200,7 +200,7 @@ class MAGNUM_EXPORT CompressedPixelStorage: public PixelStorage {
*
* If set to @cpp 0 @ce, size information from particular compressed
* format is used. Default is @cpp 0 @ce in all dimensions.
* @see @ref Magnum::compressedBlockDataSize()
* @see @ref Magnum::compressedPixelFormatBlockDataSize()
*/
CompressedPixelStorage& setCompressedBlockDataSize(Int size) {
_blockDataSize = size;
@ -249,12 +249,12 @@ constexpr PixelStorage::PixelStorage() noexcept: _rowLength{0}, _imageHeight{0},
namespace Implementation {
/* Used in templated image[view] constructors */
template<class T> inline UnsignedInt pixelSizeAdl(T format) {
return pixelSize(format);
template<class T> inline UnsignedInt pixelFormatSizeAdl(T format) {
return pixelFormatSize(format);
}
template<class T, class U> inline UnsignedInt pixelSizeAdl(T format, U formatExtra) {
return pixelSize(format, formatExtra);
template<class T, class U> inline UnsignedInt pixelFormatSizeAdl(T format, U formatExtra) {
return pixelFormatSize(format, formatExtra);
}
/* Used in image query functions */

8
src/Magnum/Test/ImageTest.cpp
Unescape View File

@ -146,8 +146,8 @@ namespace GL {
enum class PixelType { UnsignedShort = 1337 };
/* Clang -Wmissing-prototypes warns otherwise, even though this is in an
anonymous namespace */
UnsignedInt pixelSize(PixelFormat, PixelType);
UnsignedInt pixelSize(PixelFormat format, PixelType type) {
UnsignedInt pixelFormatSize(PixelFormat, PixelType);
UnsignedInt pixelFormatSize(PixelFormat format, PixelType type) {
CORRADE_INTERNAL_ASSERT(format == PixelFormat::RGB);
CORRADE_INTERNAL_ASSERT(type == PixelType::UnsignedShort);
#ifdef CORRADE_NO_ASSERT
@ -164,8 +164,8 @@ namespace Vk {
enum class PixelFormat { R32G32B32F = 42 };
/* Clang -Wmissing-prototypes warns otherwise, even though this is in an
anonymous namespace */
UnsignedInt pixelSize(PixelFormat);
UnsignedInt pixelSize(PixelFormat format) {
UnsignedInt pixelFormatSize(PixelFormat);
UnsignedInt pixelFormatSize(PixelFormat format) {
CORRADE_INTERNAL_ASSERT(format == PixelFormat::R32G32B32F);
#ifdef CORRADE_NO_ASSERT
static_cast<void>(format);

8
src/Magnum/Test/ImageViewTest.cpp
Unescape View File

@ -140,8 +140,8 @@ namespace GL {
enum class PixelType { UnsignedShort = 1337 };
/* Clang -Wmissing-prototypes warns otherwise, even though this is in an
anonymous namespace */
UnsignedInt pixelSize(PixelFormat, PixelType);
UnsignedInt pixelSize(PixelFormat format, PixelType type) {
UnsignedInt pixelFormatSize(PixelFormat, PixelType);
UnsignedInt pixelFormatSize(PixelFormat format, PixelType type) {
CORRADE_INTERNAL_ASSERT(format == PixelFormat::RGB);
CORRADE_INTERNAL_ASSERT(type == PixelType::UnsignedShort);
#ifdef CORRADE_NO_ASSERT
@ -158,8 +158,8 @@ namespace Vk {
enum class PixelFormat { R32G32B32F = 42 };
/* Clang -Wmissing-prototypes warns otherwise, even though this is in an
anonymous namespace */
UnsignedInt pixelSize(PixelFormat);
UnsignedInt pixelSize(PixelFormat format) {
UnsignedInt pixelFormatSize(PixelFormat);
UnsignedInt pixelFormatSize(PixelFormat format) {
CORRADE_INTERNAL_ASSERT(format == PixelFormat::R32G32B32F);
#ifdef CORRADE_NO_ASSERT
static_cast<void>(format);

72
src/Magnum/Test/PixelFormatTest.cpp
Unescape View File

@ -172,8 +172,8 @@ void PixelFormatTest::compressedMapping() {
CORRADE_COMPARE(Utility::ConfigurationValue<CompressedPixelFormat>::toString(CompressedPixelFormat::format, {}), #format); \
CORRADE_COMPARE(nextHandled, i); \
CORRADE_COMPARE(firstUnhandled, 0xffff); \
CORRADE_COMPARE(Magnum::compressedBlockSize(CompressedPixelFormat::format), (Vector3i{width, height, depth})); \
CORRADE_COMPARE(compressedBlockDataSize(CompressedPixelFormat::format), size/8); \
CORRADE_COMPARE(compressedPixelFormatBlockSize(CompressedPixelFormat::format), (Vector3i{width, height, depth})); \
CORRADE_COMPARE(compressedPixelFormatBlockDataSize(CompressedPixelFormat::format), size/8); \
CORRADE_COMPARE(size % 8, 0); \
CORRADE_COMPARE_AS(width, 16, TestSuite::Compare::LessOrEqual); \
CORRADE_COMPARE_AS(height, 16, TestSuite::Compare::LessOrEqual); \
@ -198,14 +198,14 @@ void PixelFormatTest::compressedMapping() {
}
void PixelFormatTest::size() {
CORRADE_COMPARE(pixelSize(PixelFormat::R8I), 1);
CORRADE_COMPARE(pixelSize(PixelFormat::R16UI), 2);
CORRADE_COMPARE(pixelSize(PixelFormat::RGB8Unorm), 3);
CORRADE_COMPARE(pixelSize(PixelFormat::RGBA8Snorm), 4);
CORRADE_COMPARE(pixelSize(PixelFormat::RGB16I), 6);
CORRADE_COMPARE(pixelSize(PixelFormat::RGBA16F), 8);
CORRADE_COMPARE(pixelSize(PixelFormat::RGB32UI), 12);
CORRADE_COMPARE(pixelSize(PixelFormat::RGBA32F), 16);
CORRADE_COMPARE(pixelFormatSize(PixelFormat::R8I), 1);
CORRADE_COMPARE(pixelFormatSize(PixelFormat::R16UI), 2);
CORRADE_COMPARE(pixelFormatSize(PixelFormat::RGB8Unorm), 3);
CORRADE_COMPARE(pixelFormatSize(PixelFormat::RGBA8Snorm), 4);
CORRADE_COMPARE(pixelFormatSize(PixelFormat::RGB16I), 6);
CORRADE_COMPARE(pixelFormatSize(PixelFormat::RGBA16F), 8);
CORRADE_COMPARE(pixelFormatSize(PixelFormat::RGB32UI), 12);
CORRADE_COMPARE(pixelFormatSize(PixelFormat::RGBA32F), 16);
}
void PixelFormatTest::sizeInvalid() {
@ -216,12 +216,12 @@ void PixelFormatTest::sizeInvalid() {
std::ostringstream out;
Error redirectError{&out};
pixelSize(PixelFormat{});
pixelSize(PixelFormat(0xdead));
pixelFormatSize(PixelFormat{});
pixelFormatSize(PixelFormat(0xdead));
CORRADE_COMPARE(out.str(),
"pixelSize(): invalid format PixelFormat(0x0)\n"
"pixelSize(): invalid format PixelFormat(0xdead)\n");
"pixelFormatSize(): invalid format PixelFormat(0x0)\n"
"pixelFormatSize(): invalid format PixelFormat(0xdead)\n");
}
void PixelFormatTest::sizeImplementationSpecific() {
@ -232,20 +232,20 @@ void PixelFormatTest::sizeImplementationSpecific() {
std::ostringstream out;
Error redirectError{&out};
pixelSize(pixelFormatWrap(0xdead));
pixelFormatSize(pixelFormatWrap(0xdead));
CORRADE_COMPARE(out.str(), "pixelSize(): can't determine size of an implementation-specific format 0xdead\n");
CORRADE_COMPARE(out.str(), "pixelFormatSize(): can't determine size of an implementation-specific format 0xdead\n");
}
void PixelFormatTest::compressedBlockSize() {
CORRADE_COMPARE(Magnum::compressedBlockSize(CompressedPixelFormat::Etc2RGB8A1Srgb), (Vector3i{4, 4, 1}));
CORRADE_COMPARE(compressedBlockDataSize(CompressedPixelFormat::Etc2RGB8A1Srgb), 8);
CORRADE_COMPARE(Magnum::compressedBlockSize(CompressedPixelFormat::Astc5x4RGBAUnorm), (Vector3i{5, 4, 1}));
CORRADE_COMPARE(compressedBlockDataSize(CompressedPixelFormat::Astc5x4RGBAUnorm), 16);
CORRADE_COMPARE(Magnum::compressedBlockSize(CompressedPixelFormat::Astc12x10RGBAUnorm), (Vector3i{12, 10, 1}));
CORRADE_COMPARE(compressedBlockDataSize(CompressedPixelFormat::Astc12x10RGBAUnorm), 16);
CORRADE_COMPARE(Magnum::compressedBlockSize(CompressedPixelFormat::PvrtcRGBA2bppUnorm), (Vector3i{8, 4, 1}));
CORRADE_COMPARE(compressedBlockDataSize(CompressedPixelFormat::PvrtcRGBA2bppUnorm), 8);
CORRADE_COMPARE(compressedPixelFormatBlockSize(CompressedPixelFormat::Etc2RGB8A1Srgb), (Vector3i{4, 4, 1}));
CORRADE_COMPARE(compressedPixelFormatBlockDataSize(CompressedPixelFormat::Etc2RGB8A1Srgb), 8);
CORRADE_COMPARE(compressedPixelFormatBlockSize(CompressedPixelFormat::Astc5x4RGBAUnorm), (Vector3i{5, 4, 1}));
CORRADE_COMPARE(compressedPixelFormatBlockDataSize(CompressedPixelFormat::Astc5x4RGBAUnorm), 16);
CORRADE_COMPARE(compressedPixelFormatBlockSize(CompressedPixelFormat::Astc12x10RGBAUnorm), (Vector3i{12, 10, 1}));
CORRADE_COMPARE(compressedPixelFormatBlockDataSize(CompressedPixelFormat::Astc12x10RGBAUnorm), 16);
CORRADE_COMPARE(compressedPixelFormatBlockSize(CompressedPixelFormat::PvrtcRGBA2bppUnorm), (Vector3i{8, 4, 1}));
CORRADE_COMPARE(compressedPixelFormatBlockDataSize(CompressedPixelFormat::PvrtcRGBA2bppUnorm), 8);
/* The rest tested in compressedMapping() */
}
@ -258,16 +258,16 @@ void PixelFormatTest::compressedBlockSizeInvalid() {
std::ostringstream out;
Error redirectError{&out};
Magnum::compressedBlockSize(CompressedPixelFormat{});
Magnum::compressedBlockSize(CompressedPixelFormat(0xdead));
compressedBlockDataSize(CompressedPixelFormat{});
compressedBlockDataSize(CompressedPixelFormat(0xdead));
compressedPixelFormatBlockSize(CompressedPixelFormat{});
compressedPixelFormatBlockSize(CompressedPixelFormat(0xdead));
compressedPixelFormatBlockDataSize(CompressedPixelFormat{});
compressedPixelFormatBlockDataSize(CompressedPixelFormat(0xdead));
CORRADE_COMPARE(out.str(),
"compressedBlockSize(): invalid format CompressedPixelFormat(0x0)\n"
"compressedBlockSize(): invalid format CompressedPixelFormat(0xdead)\n"
"compressedBlockDataSize(): invalid format CompressedPixelFormat(0x0)\n"
"compressedBlockDataSize(): invalid format CompressedPixelFormat(0xdead)\n");
"compressedPixelFormatBlockSize(): invalid format CompressedPixelFormat(0x0)\n"
"compressedPixelFormatBlockSize(): invalid format CompressedPixelFormat(0xdead)\n"
"compressedPixelFormatBlockDataSize(): invalid format CompressedPixelFormat(0x0)\n"
"compressedPixelFormatBlockDataSize(): invalid format CompressedPixelFormat(0xdead)\n");
}
void PixelFormatTest::compressedBlockSizeImplementationSpecific() {
@ -278,12 +278,12 @@ void PixelFormatTest::compressedBlockSizeImplementationSpecific() {
std::ostringstream out;
Error redirectError{&out};
Magnum::compressedBlockSize(compressedPixelFormatWrap(0xdead));
compressedBlockDataSize(compressedPixelFormatWrap(0xdead));
compressedPixelFormatBlockSize(compressedPixelFormatWrap(0xdead));
compressedPixelFormatBlockDataSize(compressedPixelFormatWrap(0xdead));
CORRADE_COMPARE(out.str(),
"compressedBlockSize(): can't determine size of an implementation-specific format 0xdead\n"
"compressedBlockDataSize(): can't determine size of an implementation-specific format 0xdead\n");
"compressedPixelFormatBlockSize(): can't determine size of an implementation-specific format 0xdead\n"
"compressedPixelFormatBlockDataSize(): can't determine size of an implementation-specific format 0xdead\n");
}
void PixelFormatTest::isImplementationSpecific() {

40
src/Magnum/Test/PixelStorageTest.cpp
Unescape View File

@ -109,15 +109,15 @@ void PixelStorageTest::dataProperties() {
PixelStorage storage;
storage.setAlignment(1);
CORRADE_COMPARE(storage.dataProperties(pixelSize(PixelFormat::RGBA8Unorm), Vector3i{0}),
CORRADE_COMPARE(storage.dataProperties(pixelFormatSize(PixelFormat::RGBA8Unorm), Vector3i{0}),
(std::pair<Vector3st, Vector3st>{{}, {0, 0, 0}}));
CORRADE_COMPARE(storage.dataProperties(pixelSize(PixelFormat::RGBA8Unorm), Vector3i{1}),
CORRADE_COMPARE(storage.dataProperties(pixelFormatSize(PixelFormat::RGBA8Unorm), Vector3i{1}),
(std::pair<Vector3st, Vector3st>{{}, {4, 1, 1}}));
CORRADE_COMPARE(storage.dataProperties(pixelSize(PixelFormat::R8Unorm), {8, 2, 1}),
CORRADE_COMPARE(storage.dataProperties(pixelFormatSize(PixelFormat::R8Unorm), {8, 2, 1}),
(std::pair<Vector3st, Vector3st>{{}, {8, 2, 1}}));
CORRADE_COMPARE(storage.dataProperties(pixelSize(PixelFormat::R8Unorm), {2, 4, 1}),
CORRADE_COMPARE(storage.dataProperties(pixelFormatSize(PixelFormat::R8Unorm), {2, 4, 1}),
(std::pair<Vector3st, Vector3st>{{}, {2, 4, 1}}));
CORRADE_COMPARE(storage.dataProperties(pixelSize(PixelFormat::R8Unorm), {2, 4, 6}),
CORRADE_COMPARE(storage.dataProperties(pixelFormatSize(PixelFormat::R8Unorm), {2, 4, 6}),
(std::pair<Vector3st, Vector3st>{{}, {2, 4, 6}}));
}
@ -126,15 +126,15 @@ void PixelStorageTest::dataPropertiesAlignment() {
storage.setAlignment(8)
.setSkip({3, 2, 1});
CORRADE_COMPARE(storage.dataProperties(pixelSize(PixelFormat::RGBA8Unorm), Vector3i{0}),
CORRADE_COMPARE(storage.dataProperties(pixelFormatSize(PixelFormat::RGBA8Unorm), Vector3i{0}),
(std::pair<Vector3st, Vector3st>{{3*4, 0, 0}, {0, 0, 0}}));
CORRADE_COMPARE(storage.dataProperties(pixelSize(PixelFormat::RGBA8Unorm), Vector3i{1}),
CORRADE_COMPARE(storage.dataProperties(pixelFormatSize(PixelFormat::RGBA8Unorm), Vector3i{1}),
(std::pair<Vector3st, Vector3st>{{12, 16, 8}, {8, 1, 1}}));
CORRADE_COMPARE(storage.dataProperties(pixelSize(PixelFormat::R8Unorm), {8, 2, 1}),
CORRADE_COMPARE(storage.dataProperties(pixelFormatSize(PixelFormat::R8Unorm), {8, 2, 1}),
(std::pair<Vector3st, Vector3st>{{3, 16, 16}, {8, 2, 1}}));
CORRADE_COMPARE(storage.dataProperties(pixelSize(PixelFormat::R8Unorm), {2, 4, 1}),
CORRADE_COMPARE(storage.dataProperties(pixelFormatSize(PixelFormat::R8Unorm), {2, 4, 1}),
(std::pair<Vector3st, Vector3st>{{3, 16, 32}, {8, 4, 1}}));
CORRADE_COMPARE(storage.dataProperties(pixelSize(PixelFormat::R8Unorm), {2, 4, 6}),
CORRADE_COMPARE(storage.dataProperties(pixelFormatSize(PixelFormat::R8Unorm), {2, 4, 6}),
(std::pair<Vector3st, Vector3st>{{3, 16, 32}, {8, 4, 6}}));
}
@ -144,15 +144,15 @@ void PixelStorageTest::dataPropertiesRowLength() {
.setRowLength(15)
.setSkip({3, 7, 0});
CORRADE_COMPARE(storage.dataProperties(pixelSize(PixelFormat::RGBA8Unorm), Vector3i{0}),
CORRADE_COMPARE(storage.dataProperties(pixelFormatSize(PixelFormat::RGBA8Unorm), Vector3i{0}),
(std::pair<Vector3st, Vector3st>{{3*4, 7*15*4, 0}, {0, 0, 0}}));
CORRADE_COMPARE(storage.dataProperties(pixelSize(PixelFormat::RGBA8Unorm), Vector3i{1}),
CORRADE_COMPARE(storage.dataProperties(pixelFormatSize(PixelFormat::RGBA8Unorm), Vector3i{1}),
(std::pair<Vector3st, Vector3st>{{3*4, 7*15*4, 0}, {60, 1, 1}}));
CORRADE_COMPARE(storage.dataProperties(pixelSize(PixelFormat::R8Unorm), {4, 2, 1}),
CORRADE_COMPARE(storage.dataProperties(pixelFormatSize(PixelFormat::R8Unorm), {4, 2, 1}),
(std::pair<Vector3st, Vector3st>{{3, 7*16, 0}, {16, 2, 1}}));
CORRADE_COMPARE(storage.dataProperties(pixelSize(PixelFormat::R8Unorm), {2, 4, 1}),
CORRADE_COMPARE(storage.dataProperties(pixelFormatSize(PixelFormat::R8Unorm), {2, 4, 1}),
(std::pair<Vector3st, Vector3st>{{3, 7*16, 0}, {16, 4, 1}}));
CORRADE_COMPARE(storage.dataProperties(pixelSize(PixelFormat::R8Unorm), {2, 4, 6}),
CORRADE_COMPARE(storage.dataProperties(pixelFormatSize(PixelFormat::R8Unorm), {2, 4, 6}),
(std::pair<Vector3st, Vector3st>{{3, 7*16, 0}, {16, 4, 6}}));
}
@ -162,15 +162,15 @@ void PixelStorageTest::dataPropertiesImageHeight() {
.setImageHeight(128)
.setSkip({3, 7, 2});
CORRADE_COMPARE(storage.dataProperties(pixelSize(PixelFormat::RGBA8Unorm), Vector3i{0}),
CORRADE_COMPARE(storage.dataProperties(pixelFormatSize(PixelFormat::RGBA8Unorm), Vector3i{0}),
(std::pair<Vector3st, Vector3st>{{3*4, 0, 0}, {0, 0, 0}}));
CORRADE_COMPARE(storage.dataProperties(pixelSize(PixelFormat::RGBA8Unorm), Vector3i{1}),
CORRADE_COMPARE(storage.dataProperties(pixelFormatSize(PixelFormat::RGBA8Unorm), Vector3i{1}),
(std::pair<Vector3st, Vector3st>{{3*4, 7*1*4, 2*128*1*4}, {4, 128, 1}}));
CORRADE_COMPARE(storage.dataProperties(pixelSize(PixelFormat::R8Unorm), {4, 2, 1}),
CORRADE_COMPARE(storage.dataProperties(pixelFormatSize(PixelFormat::R8Unorm), {4, 2, 1}),
(std::pair<Vector3st, Vector3st>{{3, 7*1*4, 2*128*4}, {4, 128, 1}}));
CORRADE_COMPARE(storage.dataProperties(pixelSize(PixelFormat::R8Unorm), {2, 4, 1}),
CORRADE_COMPARE(storage.dataProperties(pixelFormatSize(PixelFormat::R8Unorm), {2, 4, 1}),
(std::pair<Vector3st, Vector3st>{{3, 7*1*2, 2*128*2}, {2, 128, 1}}));
CORRADE_COMPARE(storage.dataProperties(pixelSize(PixelFormat::R8Unorm), {2, 4, 6}),
CORRADE_COMPARE(storage.dataProperties(pixelFormatSize(PixelFormat::R8Unorm), {2, 4, 6}),
(std::pair<Vector3st, Vector3st>{{3, 7*1*2, 2*128*2}, {2, 128, 6}}));
}

2
src/Magnum/Trade/ImageData.cpp
Unescape View File

@ -33,7 +33,7 @@
namespace Magnum { namespace Trade {
template<UnsignedInt dimensions> ImageData<dimensions>::ImageData(const PixelStorage storage, const PixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* const importerState) noexcept: ImageData{storage, format, {}, Magnum::pixelSize(format), size, std::move(data), importerState} {}
template<UnsignedInt dimensions> ImageData<dimensions>::ImageData(const PixelStorage storage, const PixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* const importerState) noexcept: ImageData{storage, format, {}, pixelFormatSize(format), size, std::move(data), importerState} {}
template<UnsignedInt dimensions> ImageData<dimensions>::ImageData(const PixelStorage storage, const PixelFormat format, const VectorTypeFor<dimensions, Int>& size, const DataFlags dataFlags, const Containers::ArrayView<const void> data, const void* const importerState) noexcept: ImageData{storage, format, size, Containers::Array<char>{const_cast<char*>(static_cast<const char*>(data.data())), data.size(), Implementation::nonOwnedArrayDeleter}, importerState} {
CORRADE_ASSERT(!(dataFlags & DataFlag::Owned),

20
src/Magnum/Trade/ImageData.h
Unescape View File

@ -186,7 +186,7 @@ template<UnsignedInt dimensions> class ImageData {
*
* Unlike with @ref ImageData(PixelStorage, PixelFormat, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&, const void*),
* where pixel size is calculated automatically using
* @ref pixelSize(PixelFormat), this allows you to specify an
* @ref pixelFormatSize(), this allows you to specify an
* implementation-specific pixel format and pixel size directly. Uses
* @ref pixelFormatWrap() internally to wrap @p format in
* @ref Magnum::PixelFormat "PixelFormat".
@ -243,8 +243,8 @@ template<UnsignedInt dimensions> class ImageData {
* @param data Image data
* @param importerState Importer-specific state
*
* Uses ADL to find a corresponding @cpp pixelSize(T, U) @ce overload,
* then calls @ref ImageData(PixelStorage, UnsignedInt, UnsignedInt, UnsignedInt, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&, const void*)
* Uses ADL to find a corresponding @cpp pixelFormatSize(T, U) @ce
* overload, then calls @ref ImageData(PixelStorage, UnsignedInt, UnsignedInt, UnsignedInt, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&, const void*)
* with calculated pixel size.
*/
template<class T, class U> explicit ImageData(PixelStorage storage, T format, U formatExtra, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* importerState = nullptr) noexcept;
@ -276,8 +276,8 @@ template<UnsignedInt dimensions> class ImageData {
* @param data Image data
* @param importerState Importer-specific state
*
* Uses ADL to find a corresponding @cpp pixelSize(T) @ce overload,
* then calls @ref ImageData(PixelStorage, UnsignedInt, UnsignedInt, UnsignedInt, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&, const void*)
* Uses ADL to find a corresponding @cpp pixelFormatSize(T) @ce
* overload, then calls @ref ImageData(PixelStorage, UnsignedInt, UnsignedInt, UnsignedInt, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&, const void*)
* with calculated pixel size and @p formatExtra set to @cpp 0 @ce.
*/
template<class T> explicit ImageData(PixelStorage storage, T format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* importerState = nullptr) noexcept;
@ -519,7 +519,7 @@ template<UnsignedInt dimensions> class ImageData {
* @brief Size of a pixel in bytes
*
* The image is expected to be uncompressed.
* @see @ref isCompressed(), @ref Magnum::pixelSize()
* @see @ref isCompressed(), @ref pixelFormatSize()
*/
UnsignedInt pixelSize() const;
@ -707,22 +707,22 @@ typedef ImageData<2> ImageData2D;
/** @brief Three-dimensional image data */
typedef ImageData<3> ImageData3D;
template<UnsignedInt dimensions> template<class T, class U> ImageData<dimensions>::ImageData(const PixelStorage storage, const T format, const U formatExtra, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* const importerState) noexcept: ImageData{storage, UnsignedInt(format), UnsignedInt(formatExtra), Magnum::Implementation::pixelSizeAdl(format, formatExtra), size, std::move(data), importerState} {
template<UnsignedInt dimensions> template<class T, class U> ImageData<dimensions>::ImageData(const PixelStorage storage, const T format, const U formatExtra, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* const importerState) noexcept: ImageData{storage, UnsignedInt(format), UnsignedInt(formatExtra), Magnum::Implementation::pixelFormatSizeAdl(format, formatExtra), size, std::move(data), importerState} {
static_assert(sizeof(T) <= 4 && sizeof(U) <= 4,
"format types larger than 32bits are not supported");
}
template<UnsignedInt dimensions> template<class T, class U> ImageData<dimensions>::ImageData(const PixelStorage storage, const T format, const U formatExtra, const VectorTypeFor<dimensions, Int>& size, const DataFlags dataFlags, const Containers::ArrayView<const void> data, const void* const importerState) noexcept: ImageData{storage, UnsignedInt(format), UnsignedInt(formatExtra), Magnum::Implementation::pixelSizeAdl(format, formatExtra), size, dataFlags, data, importerState} {
template<UnsignedInt dimensions> template<class T, class U> ImageData<dimensions>::ImageData(const PixelStorage storage, const T format, const U formatExtra, const VectorTypeFor<dimensions, Int>& size, const DataFlags dataFlags, const Containers::ArrayView<const void> data, const void* const importerState) noexcept: ImageData{storage, UnsignedInt(format), UnsignedInt(formatExtra), Magnum::Implementation::pixelFormatSizeAdl(format, formatExtra), size, dataFlags, data, importerState} {
static_assert(sizeof(T) <= 4 && sizeof(U) <= 4,
"format types larger than 32bits are not supported");
}
template<UnsignedInt dimensions> template<class T> ImageData<dimensions>::ImageData(const PixelStorage storage, const T format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* const importerState) noexcept: ImageData{storage, UnsignedInt(format), {}, Magnum::Implementation::pixelSizeAdl(format), size, std::move(data), importerState} {
template<UnsignedInt dimensions> template<class T> ImageData<dimensions>::ImageData(const PixelStorage storage, const T format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* const importerState) noexcept: ImageData{storage, UnsignedInt(format), {}, Magnum::Implementation::pixelFormatSizeAdl(format), size, std::move(data), importerState} {
static_assert(sizeof(T) <= 4,
"format types larger than 32bits are not supported");
}
template<UnsignedInt dimensions> template<class T> ImageData<dimensions>::ImageData(const PixelStorage storage, const T format, const VectorTypeFor<dimensions, Int>& size, const DataFlags dataFlags, const Containers::ArrayView<const void> data, const void* const importerState) noexcept: ImageData{storage, UnsignedInt(format), {}, Magnum::Implementation::pixelSizeAdl(format), size, dataFlags, data, importerState} {
template<UnsignedInt dimensions> template<class T> ImageData<dimensions>::ImageData(const PixelStorage storage, const T format, const VectorTypeFor<dimensions, Int>& size, const DataFlags dataFlags, const Containers::ArrayView<const void> data, const void* const importerState) noexcept: ImageData{storage, UnsignedInt(format), {}, Magnum::Implementation::pixelFormatSizeAdl(format), size, dataFlags, data, importerState} {
static_assert(sizeof(T) <= 4,
"format types larger than 32bits are not supported");
}

8
src/Magnum/Trade/Test/ImageDataTest.cpp
Unescape View File

@ -168,8 +168,8 @@ namespace GL {
enum class PixelType { UnsignedShort = 1337 };
/* Clang -Wmissing-prototypes warns otherwise, even though this is in an
anonymous namespace */
UnsignedInt pixelSize(PixelFormat, PixelType);
UnsignedInt pixelSize(PixelFormat format, PixelType type) {
UnsignedInt pixelFormatSize(PixelFormat, PixelType);
UnsignedInt pixelFormatSize(PixelFormat format, PixelType type) {
CORRADE_INTERNAL_ASSERT(format == PixelFormat::RGB);
CORRADE_INTERNAL_ASSERT(type == PixelType::UnsignedShort);
#ifdef CORRADE_NO_ASSERT
@ -186,8 +186,8 @@ namespace Vk {
enum class PixelFormat { R32G32B32F = 42 };
/* Clang -Wmissing-prototypes warns otherwise, even though this is in an
anonymous namespace */
UnsignedInt pixelSize(PixelFormat);
UnsignedInt pixelSize(PixelFormat format) {
UnsignedInt pixelFormatSize(PixelFormat);
UnsignedInt pixelFormatSize(PixelFormat format) {
CORRADE_INTERNAL_ASSERT(format == PixelFormat::R32G32B32F);
#ifdef CORRADE_NO_ASSERT
static_cast<void>(format);

2
src/Magnum/Trade/imageconverter.cpp
Unescape View File

@ -478,7 +478,7 @@ no -C / --converter is specified, AnyImageConverter is used.)")
Error{} << "Invalid raw pixel format" << args.value("importer");
return 4;
}
const UnsignedInt pixelSize = Magnum::pixelSize(format);
const UnsignedInt pixelSize = pixelFormatSize(format);
/* Read the file or map it if requested */
Containers::Array<char> data;

Write Preview
Loading…
Cancel
Save