ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6026 Commits
21 Branches
19 Tags
70 MiB
Tree: 7021e405a8
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '7021e405a8'
${ noResults }
magnum/src/Magnum/Trade/ImageData.cpp

100 lines
6.0 KiB
Raw Normal View History Unescape

Compressed image support, part 6: Compressed* image classes. Added (now empty) AbstractCompressedImage class that inherits (now also empty) AbstractImage class. Added CompressedBufferImage, CompressedImage and CompressedImageView classes, which are just copies of BufferImage, Image and ImageView classes with format/type pair replaced by just format, but they additionally need data size parameter. Because of different use cases in Trade, the Trade::ImageData class now handles both uncompressed and compressed format, checking the API usage with runtime assertions. The reason for this is that a material could just reference a image file by ID and we need to be able to extract image of that ID without prior knowledge whether it is compressed or not. Requiring prior knowledge of image format from the user would make both the API and the usage far more complicated than having Trade::ImageData which handles both cases. On the other hand, the Image*/CompressedImage* distinction is done for easier usage and type-safe APIs in all other cases.
11 years ago
/*
This file is part of Magnum.
Updated copyright year.
8 years ago
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018
Compressed image support, part 6: Compressed* image classes. Added (now empty) AbstractCompressedImage class that inherits (now also empty) AbstractImage class. Added CompressedBufferImage, CompressedImage and CompressedImageView classes, which are just copies of BufferImage, Image and ImageView classes with format/type pair replaced by just format, but they additionally need data size parameter. Because of different use cases in Trade, the Trade::ImageData class now handles both uncompressed and compressed format, checking the API usage with runtime assertions. The reason for this is that a material could just reference a image file by ID and we need to be able to extract image of that ID without prior knowledge whether it is compressed or not. Requiring prior knowledge of image format from the user would make both the API and the usage far more complicated than having Trade::ImageData which handles both cases. On the other hand, the Image*/CompressedImage* distinction is done for easier usage and type-safe APIs in all other cases.
11 years ago
Vladimír Vondruš <mosra@centrum.cz>
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/
#include "ImageData.h"
Split the OpenGL layer out, pt 9: generic pixel formats. This is quite big, so: * There are new Magnum::PixelFormat and Magnum::CompressedPixelFormat enums, which contain generic API-independent formats. In particular, PixelFormat replaces GL::PixelFormat and GL::PixelType with a single value. * There's GL::pixelFormat(), GL::pixelType(), GL::compressedPixelFormat() to convert the generic enums to GL-specific. The mapping is only in one direction, done with a lookup table (generic enums are indices to that table). * GL classes taking the formats directly (such as GL::BufferImage) have overloads that take both the GL-specific and generic format. * The generic Image, CompressedImage, ImageView, CompressedImageView, and Trade::ImageData classes now accept the generic formats first-class. However, it's also possible to store an implementation-specific value to cover cases where a generic format enum doesn't have support for a particular format. This is done by wrapping the value using pixelFormatWrap() or compressedPixelFormatWrap(). Particular GPU APIs then assume it's their implementation-specific value and extract the value back using pixelFormatUnwrap() or compressedPixelFormatUnwrap(). There's also an isPixelFormatImplementationSpecific() and isCompressedPixelFormatImplementationSpecific() that distinguishes these values. * Many operations need pixel size and in order to have it even for implementation-specific formats, a corresponding pixelSize() overload is found via ADL on construction and the calculated size stored along the format. Previously the pixel size was only calculated on demand, but that's not possible now. In case such overload is not available, it's possible to pass pixel size manually as well. * In order to support the GL format+type pair, Image, ImageView and Trade::ImageData, there's now an additional untyped formatExtra() field that holds the second value. * The CompressedPixelStorage class is now unconditionally available on all targets, including OpenGL ES and WebGL. However, on OpenGL ES the GL APIs expect that it's all at default values. I attempted to preserve backwards compatibility as much as possible: * The PixelFormat and CompressedPixelFormat enum now contains generic API-independent values. The GL-specific formats are present there, but marked as deprecated. Use either the generic values or GL::PixelFormat (togehter with GL::PixelType) and GL::CompressedPixelFormat instead. There's a lot of ugliness caused by this, but seems to work well. * *Image::type() functions are deprecated as they were too GL-specific. Use formatExtra() and cast it to GL::PixelType instead. * Image constructors take templated format or format+extra arguments, so passing GL-specific values to them should still work.
8 years ago
#include "Magnum/PixelFormat.h"
Compressed image support, part 6: Compressed* image classes. Added (now empty) AbstractCompressedImage class that inherits (now also empty) AbstractImage class. Added CompressedBufferImage, CompressedImage and CompressedImageView classes, which are just copies of BufferImage, Image and ImageView classes with format/type pair replaced by just format, but they additionally need data size parameter. Because of different use cases in Trade, the Trade::ImageData class now handles both uncompressed and compressed format, checking the API usage with runtime assertions. The reason for this is that a material could just reference a image file by ID and we need to be able to extract image of that ID without prior knowledge whether it is compressed or not. Requiring prior knowledge of image format from the user would make both the API and the usage far more complicated than having Trade::ImageData which handles both cases. On the other hand, the Image*/CompressedImage* distinction is done for easier usage and type-safe APIs in all other cases.
11 years ago
namespace Magnum { namespace Trade {
Split the OpenGL layer out, pt 9: generic pixel formats. This is quite big, so: * There are new Magnum::PixelFormat and Magnum::CompressedPixelFormat enums, which contain generic API-independent formats. In particular, PixelFormat replaces GL::PixelFormat and GL::PixelType with a single value. * There's GL::pixelFormat(), GL::pixelType(), GL::compressedPixelFormat() to convert the generic enums to GL-specific. The mapping is only in one direction, done with a lookup table (generic enums are indices to that table). * GL classes taking the formats directly (such as GL::BufferImage) have overloads that take both the GL-specific and generic format. * The generic Image, CompressedImage, ImageView, CompressedImageView, and Trade::ImageData classes now accept the generic formats first-class. However, it's also possible to store an implementation-specific value to cover cases where a generic format enum doesn't have support for a particular format. This is done by wrapping the value using pixelFormatWrap() or compressedPixelFormatWrap(). Particular GPU APIs then assume it's their implementation-specific value and extract the value back using pixelFormatUnwrap() or compressedPixelFormatUnwrap(). There's also an isPixelFormatImplementationSpecific() and isCompressedPixelFormatImplementationSpecific() that distinguishes these values. * Many operations need pixel size and in order to have it even for implementation-specific formats, a corresponding pixelSize() overload is found via ADL on construction and the calculated size stored along the format. Previously the pixel size was only calculated on demand, but that's not possible now. In case such overload is not available, it's possible to pass pixel size manually as well. * In order to support the GL format+type pair, Image, ImageView and Trade::ImageData, there's now an additional untyped formatExtra() field that holds the second value. * The CompressedPixelStorage class is now unconditionally available on all targets, including OpenGL ES and WebGL. However, on OpenGL ES the GL APIs expect that it's all at default values. I attempted to preserve backwards compatibility as much as possible: * The PixelFormat and CompressedPixelFormat enum now contains generic API-independent values. The GL-specific formats are present there, but marked as deprecated. Use either the generic values or GL::PixelFormat (togehter with GL::PixelType) and GL::CompressedPixelFormat instead. There's a lot of ugliness caused by this, but seems to work well. * *Image::type() functions are deprecated as they were too GL-specific. Use formatExtra() and cast it to GL::PixelType instead. * Image constructors take templated format or format+extra arguments, so passing GL-specific values to them should still work.
8 years ago
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 UnsignedInt format, const UnsignedInt formatExtra, const UnsignedInt pixelSize, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* const importerState) noexcept: ImageData{storage, pixelFormatWrap(format), formatExtra, pixelSize, size, std::move(data), importerState} {}
template<UnsignedInt dimensions> ImageData<dimensions>::ImageData(const PixelStorage storage, const PixelFormat format, const UnsignedInt formatExtra, const UnsignedInt pixelSize, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* const importerState) noexcept: _compressed{false}, _storage{storage}, _format{format}, _formatExtra{formatExtra}, _pixelSize{pixelSize}, _size{size}, _data{std::move(data)}, _importerState{importerState} {
Split the OpenGL layer out, pt 10: test the new image APIs. With the previous commits the original tests passed (which is desired), but these were using deprecated functionality and not covering the new stuff. These tests are not using the deprecated functionality, which means I don't need to build them as part of the GL library anymore. The GL::BufferImage test is still using the deprecated functionality though, in order to check I didn't break anything by accident.
8 years ago
CORRADE_ASSERT(Implementation::imageDataSize(*this) <= _data.size(), "Trade::ImageData::ImageData(): data too small, got" << _data.size() << "but expected at least" << Implementation::imageDataSize(*this) << "bytes", );
Pixel storage support, part 6: accepting only sized data arrays in images. Makes it far easier to detect pixel storage misconfigurations and improperly sized data arrays. Data owning classes (Image, Trade::ImageData) accept Containers::Array<char> while wrappers (ImageView, BufferImage) accept Containers::ArrayView<const void>. ImageView reinterprets the passed array as const char to enable pointer arithmetic on the data. The old way (constructor/setData() call accepting void*) is now marked as deprecated and will be removed in some future release. Because decay of fixed-size arrays to void* is preferred to calling Containers::ArrayView constructor, there are two more overloads to have proper handling of const T(&)[n] and std::nullptr_t arguments. Currently the TgaImporter and TgaImageConverter fail on images with row length not aligned to 4, will fix that in followup commits.
11 years ago
}
Split the OpenGL layer out, pt 9: generic pixel formats. This is quite big, so: * There are new Magnum::PixelFormat and Magnum::CompressedPixelFormat enums, which contain generic API-independent formats. In particular, PixelFormat replaces GL::PixelFormat and GL::PixelType with a single value. * There's GL::pixelFormat(), GL::pixelType(), GL::compressedPixelFormat() to convert the generic enums to GL-specific. The mapping is only in one direction, done with a lookup table (generic enums are indices to that table). * GL classes taking the formats directly (such as GL::BufferImage) have overloads that take both the GL-specific and generic format. * The generic Image, CompressedImage, ImageView, CompressedImageView, and Trade::ImageData classes now accept the generic formats first-class. However, it's also possible to store an implementation-specific value to cover cases where a generic format enum doesn't have support for a particular format. This is done by wrapping the value using pixelFormatWrap() or compressedPixelFormatWrap(). Particular GPU APIs then assume it's their implementation-specific value and extract the value back using pixelFormatUnwrap() or compressedPixelFormatUnwrap(). There's also an isPixelFormatImplementationSpecific() and isCompressedPixelFormatImplementationSpecific() that distinguishes these values. * Many operations need pixel size and in order to have it even for implementation-specific formats, a corresponding pixelSize() overload is found via ADL on construction and the calculated size stored along the format. Previously the pixel size was only calculated on demand, but that's not possible now. In case such overload is not available, it's possible to pass pixel size manually as well. * In order to support the GL format+type pair, Image, ImageView and Trade::ImageData, there's now an additional untyped formatExtra() field that holds the second value. * The CompressedPixelStorage class is now unconditionally available on all targets, including OpenGL ES and WebGL. However, on OpenGL ES the GL APIs expect that it's all at default values. I attempted to preserve backwards compatibility as much as possible: * The PixelFormat and CompressedPixelFormat enum now contains generic API-independent values. The GL-specific formats are present there, but marked as deprecated. Use either the generic values or GL::PixelFormat (togehter with GL::PixelType) and GL::CompressedPixelFormat instead. There's a lot of ugliness caused by this, but seems to work well. * *Image::type() functions are deprecated as they were too GL-specific. Use formatExtra() and cast it to GL::PixelType instead. * Image constructors take templated format or format+extra arguments, so passing GL-specific values to them should still work.
8 years ago
template<UnsignedInt dimensions> ImageData<dimensions>::ImageData(const CompressedPixelStorage storage, const CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* const importerState) noexcept: _compressed{true}, _compressedStorage{storage}, _compressedFormat{format}, _size{size}, _data{std::move(data)}, _importerState{importerState} {}
template<UnsignedInt dimensions> ImageData<dimensions>::ImageData(const CompressedPixelStorage storage, const UnsignedInt format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* const importerState) noexcept: ImageData{storage, compressedPixelFormatWrap(format), size, std::move(data), importerState} {}
Pixel storage support, part 4: the PixelStorage class. Just created, documented and used the class in images, nothing is used anywhere yet.
11 years ago
template<UnsignedInt dimensions> PixelStorage ImageData<dimensions>::storage() const {
CORRADE_ASSERT(!_compressed, "Trade::ImageData::storage(): the image is compressed", {});
return _storage;
}
Pixel storage support, part 2: renamed ColorFormat to PixelFormat etc. Yeah, sorry, I know, the enums are renamed for second or third time in a row, first they were Image::Format, then ImageFormat, then ColorFormat and now PixelFormat. But this time it's final and last time they are renamed and now everything is finally consistent: * ColorFormat::DepthComponent -- depth is not a color, thus PixelFormat::DepthComponent makes a lot more sense. * There will be PixelStorage classes, which will be stored in images alonside PixelFormat/PixelType enums, making everything nicely aligned. * The GL documentation about glTexImage2D() etc. denotes the <format> and <type> parameters as format and type of *pixel* data, so now we are _finally_ consistent with the official naming. I wonder why did I not choose PixelFormat originally. Anyway, the old <Magnum/ColorFormat.h> header, ColorFormat, ColorType and CompressedColorFormat types are now aliases to the new ones, are marked as deprecated and will be removed in some future release (as always, I'm waiting at least six months before removing the deprecated functionality).
11 years ago
template<UnsignedInt dimensions> PixelFormat ImageData<dimensions>::format() const {
Compressed image support, part 6: Compressed* image classes. Added (now empty) AbstractCompressedImage class that inherits (now also empty) AbstractImage class. Added CompressedBufferImage, CompressedImage and CompressedImageView classes, which are just copies of BufferImage, Image and ImageView classes with format/type pair replaced by just format, but they additionally need data size parameter. Because of different use cases in Trade, the Trade::ImageData class now handles both uncompressed and compressed format, checking the API usage with runtime assertions. The reason for this is that a material could just reference a image file by ID and we need to be able to extract image of that ID without prior knowledge whether it is compressed or not. Requiring prior knowledge of image format from the user would make both the API and the usage far more complicated than having Trade::ImageData which handles both cases. On the other hand, the Image*/CompressedImage* distinction is done for easier usage and type-safe APIs in all other cases.
11 years ago
CORRADE_ASSERT(!_compressed, "Trade::ImageData::format(): the image is compressed", {});
return _format;
}
Split the OpenGL layer out, pt 9: generic pixel formats. This is quite big, so: * There are new Magnum::PixelFormat and Magnum::CompressedPixelFormat enums, which contain generic API-independent formats. In particular, PixelFormat replaces GL::PixelFormat and GL::PixelType with a single value. * There's GL::pixelFormat(), GL::pixelType(), GL::compressedPixelFormat() to convert the generic enums to GL-specific. The mapping is only in one direction, done with a lookup table (generic enums are indices to that table). * GL classes taking the formats directly (such as GL::BufferImage) have overloads that take both the GL-specific and generic format. * The generic Image, CompressedImage, ImageView, CompressedImageView, and Trade::ImageData classes now accept the generic formats first-class. However, it's also possible to store an implementation-specific value to cover cases where a generic format enum doesn't have support for a particular format. This is done by wrapping the value using pixelFormatWrap() or compressedPixelFormatWrap(). Particular GPU APIs then assume it's their implementation-specific value and extract the value back using pixelFormatUnwrap() or compressedPixelFormatUnwrap(). There's also an isPixelFormatImplementationSpecific() and isCompressedPixelFormatImplementationSpecific() that distinguishes these values. * Many operations need pixel size and in order to have it even for implementation-specific formats, a corresponding pixelSize() overload is found via ADL on construction and the calculated size stored along the format. Previously the pixel size was only calculated on demand, but that's not possible now. In case such overload is not available, it's possible to pass pixel size manually as well. * In order to support the GL format+type pair, Image, ImageView and Trade::ImageData, there's now an additional untyped formatExtra() field that holds the second value. * The CompressedPixelStorage class is now unconditionally available on all targets, including OpenGL ES and WebGL. However, on OpenGL ES the GL APIs expect that it's all at default values. I attempted to preserve backwards compatibility as much as possible: * The PixelFormat and CompressedPixelFormat enum now contains generic API-independent values. The GL-specific formats are present there, but marked as deprecated. Use either the generic values or GL::PixelFormat (togehter with GL::PixelType) and GL::CompressedPixelFormat instead. There's a lot of ugliness caused by this, but seems to work well. * *Image::type() functions are deprecated as they were too GL-specific. Use formatExtra() and cast it to GL::PixelType instead. * Image constructors take templated format or format+extra arguments, so passing GL-specific values to them should still work.
8 years ago
template<UnsignedInt dimensions> UnsignedInt ImageData<dimensions>::formatExtra() const {
CORRADE_ASSERT(!_compressed, "Trade::ImageData::formatExtra(): the image is compressed", {});
return _formatExtra;
Compressed image support, part 6: Compressed* image classes. Added (now empty) AbstractCompressedImage class that inherits (now also empty) AbstractImage class. Added CompressedBufferImage, CompressedImage and CompressedImageView classes, which are just copies of BufferImage, Image and ImageView classes with format/type pair replaced by just format, but they additionally need data size parameter. Because of different use cases in Trade, the Trade::ImageData class now handles both uncompressed and compressed format, checking the API usage with runtime assertions. The reason for this is that a material could just reference a image file by ID and we need to be able to extract image of that ID without prior knowledge whether it is compressed or not. Requiring prior knowledge of image format from the user would make both the API and the usage far more complicated than having Trade::ImageData which handles both cases. On the other hand, the Image*/CompressedImage* distinction is done for easier usage and type-safe APIs in all other cases.
11 years ago
}
Pixel storage support, part 4: the PixelStorage class. Just created, documented and used the class in images, nothing is used anywhere yet.
11 years ago
template<UnsignedInt dimensions> CompressedPixelStorage ImageData<dimensions>::compressedStorage() const {
CORRADE_ASSERT(_compressed, "Trade::ImageData::compressedStorage(): the image is not compressed", {});
return _compressedStorage;
}
Pixel storage support, part 2: renamed ColorFormat to PixelFormat etc. Yeah, sorry, I know, the enums are renamed for second or third time in a row, first they were Image::Format, then ImageFormat, then ColorFormat and now PixelFormat. But this time it's final and last time they are renamed and now everything is finally consistent: * ColorFormat::DepthComponent -- depth is not a color, thus PixelFormat::DepthComponent makes a lot more sense. * There will be PixelStorage classes, which will be stored in images alonside PixelFormat/PixelType enums, making everything nicely aligned. * The GL documentation about glTexImage2D() etc. denotes the <format> and <type> parameters as format and type of *pixel* data, so now we are _finally_ consistent with the official naming. I wonder why did I not choose PixelFormat originally. Anyway, the old <Magnum/ColorFormat.h> header, ColorFormat, ColorType and CompressedColorFormat types are now aliases to the new ones, are marked as deprecated and will be removed in some future release (as always, I'm waiting at least six months before removing the deprecated functionality).
11 years ago
template<UnsignedInt dimensions> CompressedPixelFormat ImageData<dimensions>::compressedFormat() const {
Pixel storage support, part 4: the PixelStorage class. Just created, documented and used the class in images, nothing is used anywhere yet.
11 years ago
CORRADE_ASSERT(_compressed, "Trade::ImageData::compressedFormat(): the image is not compressed", {});
Compressed image support, part 6: Compressed* image classes. Added (now empty) AbstractCompressedImage class that inherits (now also empty) AbstractImage class. Added CompressedBufferImage, CompressedImage and CompressedImageView classes, which are just copies of BufferImage, Image and ImageView classes with format/type pair replaced by just format, but they additionally need data size parameter. Because of different use cases in Trade, the Trade::ImageData class now handles both uncompressed and compressed format, checking the API usage with runtime assertions. The reason for this is that a material could just reference a image file by ID and we need to be able to extract image of that ID without prior knowledge whether it is compressed or not. Requiring prior knowledge of image format from the user would make both the API and the usage far more complicated than having Trade::ImageData which handles both cases. On the other hand, the Image*/CompressedImage* distinction is done for easier usage and type-safe APIs in all other cases.
11 years ago
return _compressedFormat;
}
Split the OpenGL layer out, pt 9: generic pixel formats. This is quite big, so: * There are new Magnum::PixelFormat and Magnum::CompressedPixelFormat enums, which contain generic API-independent formats. In particular, PixelFormat replaces GL::PixelFormat and GL::PixelType with a single value. * There's GL::pixelFormat(), GL::pixelType(), GL::compressedPixelFormat() to convert the generic enums to GL-specific. The mapping is only in one direction, done with a lookup table (generic enums are indices to that table). * GL classes taking the formats directly (such as GL::BufferImage) have overloads that take both the GL-specific and generic format. * The generic Image, CompressedImage, ImageView, CompressedImageView, and Trade::ImageData classes now accept the generic formats first-class. However, it's also possible to store an implementation-specific value to cover cases where a generic format enum doesn't have support for a particular format. This is done by wrapping the value using pixelFormatWrap() or compressedPixelFormatWrap(). Particular GPU APIs then assume it's their implementation-specific value and extract the value back using pixelFormatUnwrap() or compressedPixelFormatUnwrap(). There's also an isPixelFormatImplementationSpecific() and isCompressedPixelFormatImplementationSpecific() that distinguishes these values. * Many operations need pixel size and in order to have it even for implementation-specific formats, a corresponding pixelSize() overload is found via ADL on construction and the calculated size stored along the format. Previously the pixel size was only calculated on demand, but that's not possible now. In case such overload is not available, it's possible to pass pixel size manually as well. * In order to support the GL format+type pair, Image, ImageView and Trade::ImageData, there's now an additional untyped formatExtra() field that holds the second value. * The CompressedPixelStorage class is now unconditionally available on all targets, including OpenGL ES and WebGL. However, on OpenGL ES the GL APIs expect that it's all at default values. I attempted to preserve backwards compatibility as much as possible: * The PixelFormat and CompressedPixelFormat enum now contains generic API-independent values. The GL-specific formats are present there, but marked as deprecated. Use either the generic values or GL::PixelFormat (togehter with GL::PixelType) and GL::CompressedPixelFormat instead. There's a lot of ugliness caused by this, but seems to work well. * *Image::type() functions are deprecated as they were too GL-specific. Use formatExtra() and cast it to GL::PixelType instead. * Image constructors take templated format or format+extra arguments, so passing GL-specific values to them should still work.
8 years ago
template<UnsignedInt dimensions> UnsignedInt ImageData<dimensions>::pixelSize() const {
Compressed image support, part 6: Compressed* image classes. Added (now empty) AbstractCompressedImage class that inherits (now also empty) AbstractImage class. Added CompressedBufferImage, CompressedImage and CompressedImageView classes, which are just copies of BufferImage, Image and ImageView classes with format/type pair replaced by just format, but they additionally need data size parameter. Because of different use cases in Trade, the Trade::ImageData class now handles both uncompressed and compressed format, checking the API usage with runtime assertions. The reason for this is that a material could just reference a image file by ID and we need to be able to extract image of that ID without prior knowledge whether it is compressed or not. Requiring prior knowledge of image format from the user would make both the API and the usage far more complicated than having Trade::ImageData which handles both cases. On the other hand, the Image*/CompressedImage* distinction is done for easier usage and type-safe APIs in all other cases.
11 years ago
CORRADE_ASSERT(!_compressed, "Trade::ImageData::pixelSize(): the image is compressed", {});
Split the OpenGL layer out, pt 9: generic pixel formats. This is quite big, so: * There are new Magnum::PixelFormat and Magnum::CompressedPixelFormat enums, which contain generic API-independent formats. In particular, PixelFormat replaces GL::PixelFormat and GL::PixelType with a single value. * There's GL::pixelFormat(), GL::pixelType(), GL::compressedPixelFormat() to convert the generic enums to GL-specific. The mapping is only in one direction, done with a lookup table (generic enums are indices to that table). * GL classes taking the formats directly (such as GL::BufferImage) have overloads that take both the GL-specific and generic format. * The generic Image, CompressedImage, ImageView, CompressedImageView, and Trade::ImageData classes now accept the generic formats first-class. However, it's also possible to store an implementation-specific value to cover cases where a generic format enum doesn't have support for a particular format. This is done by wrapping the value using pixelFormatWrap() or compressedPixelFormatWrap(). Particular GPU APIs then assume it's their implementation-specific value and extract the value back using pixelFormatUnwrap() or compressedPixelFormatUnwrap(). There's also an isPixelFormatImplementationSpecific() and isCompressedPixelFormatImplementationSpecific() that distinguishes these values. * Many operations need pixel size and in order to have it even for implementation-specific formats, a corresponding pixelSize() overload is found via ADL on construction and the calculated size stored along the format. Previously the pixel size was only calculated on demand, but that's not possible now. In case such overload is not available, it's possible to pass pixel size manually as well. * In order to support the GL format+type pair, Image, ImageView and Trade::ImageData, there's now an additional untyped formatExtra() field that holds the second value. * The CompressedPixelStorage class is now unconditionally available on all targets, including OpenGL ES and WebGL. However, on OpenGL ES the GL APIs expect that it's all at default values. I attempted to preserve backwards compatibility as much as possible: * The PixelFormat and CompressedPixelFormat enum now contains generic API-independent values. The GL-specific formats are present there, but marked as deprecated. Use either the generic values or GL::PixelFormat (togehter with GL::PixelType) and GL::CompressedPixelFormat instead. There's a lot of ugliness caused by this, but seems to work well. * *Image::type() functions are deprecated as they were too GL-specific. Use formatExtra() and cast it to GL::PixelType instead. * Image constructors take templated format or format+extra arguments, so passing GL-specific values to them should still work.
8 years ago
return _pixelSize;
Compressed image support, part 6: Compressed* image classes. Added (now empty) AbstractCompressedImage class that inherits (now also empty) AbstractImage class. Added CompressedBufferImage, CompressedImage and CompressedImageView classes, which are just copies of BufferImage, Image and ImageView classes with format/type pair replaced by just format, but they additionally need data size parameter. Because of different use cases in Trade, the Trade::ImageData class now handles both uncompressed and compressed format, checking the API usage with runtime assertions. The reason for this is that a material could just reference a image file by ID and we need to be able to extract image of that ID without prior knowledge whether it is compressed or not. Requiring prior knowledge of image format from the user would make both the API and the usage far more complicated than having Trade::ImageData which handles both cases. On the other hand, the Image*/CompressedImage* distinction is done for easier usage and type-safe APIs in all other cases.
11 years ago
}
Don't return redundant info from Image*::dataProperties(). It was returning either pixel size or compressed block size, which is now available directly via other means. This is a breaking change, but I don't expect these functions to be used widely beyond Magnum internals.
8 years ago
template<UnsignedInt dimensions> std::pair<VectorTypeFor<dimensions, std::size_t>, VectorTypeFor<dimensions, std::size_t>> ImageData<dimensions>::dataProperties() const {
Pixel storage support, part 5: new data properties computation. Removed *Image::dataSize() and added *Image::dataProperties(), which returns all properties separately for better introspection. This function is now just an convenience alias to PixelStorage::dataProperties(), which takes into account proper alignment and all other storage properties.
11 years ago
CORRADE_ASSERT(!_compressed, "Trade::ImageData::dataProperties(): the image is compressed", {});
return Implementation::imageDataProperties<dimensions>(*this);
Compressed image support, part 6: Compressed* image classes. Added (now empty) AbstractCompressedImage class that inherits (now also empty) AbstractImage class. Added CompressedBufferImage, CompressedImage and CompressedImageView classes, which are just copies of BufferImage, Image and ImageView classes with format/type pair replaced by just format, but they additionally need data size parameter. Because of different use cases in Trade, the Trade::ImageData class now handles both uncompressed and compressed format, checking the API usage with runtime assertions. The reason for this is that a material could just reference a image file by ID and we need to be able to extract image of that ID without prior knowledge whether it is compressed or not. Requiring prior knowledge of image format from the user would make both the API and the usage far more complicated than having Trade::ImageData which handles both cases. On the other hand, the Image*/CompressedImage* distinction is done for easier usage and type-safe APIs in all other cases.
11 years ago
}
Remove lvalue restrictions when converting images to image views. It is a valid usecase, e.g. when saving a screenshot in an oneliner: pngImageConverter->exportToFile(defaultFramebuffer.read( defaultFramebuffer.viewport(), {PixelFormat::RGB, PixelType::UnsignedByte}), "screenshot.png");
11 years ago
template<UnsignedInt dimensions> ImageData<dimensions>::operator ImageView<dimensions>() const
Compressed image support, part 6: Compressed* image classes. Added (now empty) AbstractCompressedImage class that inherits (now also empty) AbstractImage class. Added CompressedBufferImage, CompressedImage and CompressedImageView classes, which are just copies of BufferImage, Image and ImageView classes with format/type pair replaced by just format, but they additionally need data size parameter. Because of different use cases in Trade, the Trade::ImageData class now handles both uncompressed and compressed format, checking the API usage with runtime assertions. The reason for this is that a material could just reference a image file by ID and we need to be able to extract image of that ID without prior knowledge whether it is compressed or not. Requiring prior knowledge of image format from the user would make both the API and the usage far more complicated than having Trade::ImageData which handles both cases. On the other hand, the Image*/CompressedImage* distinction is done for easier usage and type-safe APIs in all other cases.
11 years ago
{
Split the OpenGL layer out, pt 9: generic pixel formats. This is quite big, so: * There are new Magnum::PixelFormat and Magnum::CompressedPixelFormat enums, which contain generic API-independent formats. In particular, PixelFormat replaces GL::PixelFormat and GL::PixelType with a single value. * There's GL::pixelFormat(), GL::pixelType(), GL::compressedPixelFormat() to convert the generic enums to GL-specific. The mapping is only in one direction, done with a lookup table (generic enums are indices to that table). * GL classes taking the formats directly (such as GL::BufferImage) have overloads that take both the GL-specific and generic format. * The generic Image, CompressedImage, ImageView, CompressedImageView, and Trade::ImageData classes now accept the generic formats first-class. However, it's also possible to store an implementation-specific value to cover cases where a generic format enum doesn't have support for a particular format. This is done by wrapping the value using pixelFormatWrap() or compressedPixelFormatWrap(). Particular GPU APIs then assume it's their implementation-specific value and extract the value back using pixelFormatUnwrap() or compressedPixelFormatUnwrap(). There's also an isPixelFormatImplementationSpecific() and isCompressedPixelFormatImplementationSpecific() that distinguishes these values. * Many operations need pixel size and in order to have it even for implementation-specific formats, a corresponding pixelSize() overload is found via ADL on construction and the calculated size stored along the format. Previously the pixel size was only calculated on demand, but that's not possible now. In case such overload is not available, it's possible to pass pixel size manually as well. * In order to support the GL format+type pair, Image, ImageView and Trade::ImageData, there's now an additional untyped formatExtra() field that holds the second value. * The CompressedPixelStorage class is now unconditionally available on all targets, including OpenGL ES and WebGL. However, on OpenGL ES the GL APIs expect that it's all at default values. I attempted to preserve backwards compatibility as much as possible: * The PixelFormat and CompressedPixelFormat enum now contains generic API-independent values. The GL-specific formats are present there, but marked as deprecated. Use either the generic values or GL::PixelFormat (togehter with GL::PixelType) and GL::CompressedPixelFormat instead. There's a lot of ugliness caused by this, but seems to work well. * *Image::type() functions are deprecated as they were too GL-specific. Use formatExtra() and cast it to GL::PixelType instead. * Image constructors take templated format or format+extra arguments, so passing GL-specific values to them should still work.
8 years ago
CORRADE_ASSERT(!_compressed, "Trade::ImageData::type(): the image is compressed", (ImageView<dimensions>{_storage, _format, _formatExtra, _pixelSize, _size}));
return ImageView<dimensions>{_storage, _format, _formatExtra, _pixelSize, _size, _data};
Compressed image support, part 6: Compressed* image classes. Added (now empty) AbstractCompressedImage class that inherits (now also empty) AbstractImage class. Added CompressedBufferImage, CompressedImage and CompressedImageView classes, which are just copies of BufferImage, Image and ImageView classes with format/type pair replaced by just format, but they additionally need data size parameter. Because of different use cases in Trade, the Trade::ImageData class now handles both uncompressed and compressed format, checking the API usage with runtime assertions. The reason for this is that a material could just reference a image file by ID and we need to be able to extract image of that ID without prior knowledge whether it is compressed or not. Requiring prior knowledge of image format from the user would make both the API and the usage far more complicated than having Trade::ImageData which handles both cases. On the other hand, the Image*/CompressedImage* distinction is done for easier usage and type-safe APIs in all other cases.
11 years ago
}
Remove lvalue restrictions when converting images to image views. It is a valid usecase, e.g. when saving a screenshot in an oneliner: pngImageConverter->exportToFile(defaultFramebuffer.read( defaultFramebuffer.viewport(), {PixelFormat::RGB, PixelType::UnsignedByte}), "screenshot.png");
11 years ago
template<UnsignedInt dimensions> ImageData<dimensions>::operator CompressedImageView<dimensions>() const
Compressed image support, part 6: Compressed* image classes. Added (now empty) AbstractCompressedImage class that inherits (now also empty) AbstractImage class. Added CompressedBufferImage, CompressedImage and CompressedImageView classes, which are just copies of BufferImage, Image and ImageView classes with format/type pair replaced by just format, but they additionally need data size parameter. Because of different use cases in Trade, the Trade::ImageData class now handles both uncompressed and compressed format, checking the API usage with runtime assertions. The reason for this is that a material could just reference a image file by ID and we need to be able to extract image of that ID without prior knowledge whether it is compressed or not. Requiring prior knowledge of image format from the user would make both the API and the usage far more complicated than having Trade::ImageData which handles both cases. On the other hand, the Image*/CompressedImage* distinction is done for easier usage and type-safe APIs in all other cases.
11 years ago
{
Pixel storage support, part 4: the PixelStorage class. Just created, documented and used the class in images, nothing is used anywhere yet.
11 years ago
CORRADE_ASSERT(_compressed, "Trade::ImageData::type(): the image is not compressed", (CompressedImageView<dimensions>{_compressedStorage, _compressedFormat, _size}));
return CompressedImageView<dimensions>{
_compressedStorage,
_compressedFormat, _size, _data};
Compressed image support, part 6: Compressed* image classes. Added (now empty) AbstractCompressedImage class that inherits (now also empty) AbstractImage class. Added CompressedBufferImage, CompressedImage and CompressedImageView classes, which are just copies of BufferImage, Image and ImageView classes with format/type pair replaced by just format, but they additionally need data size parameter. Because of different use cases in Trade, the Trade::ImageData class now handles both uncompressed and compressed format, checking the API usage with runtime assertions. The reason for this is that a material could just reference a image file by ID and we need to be able to extract image of that ID without prior knowledge whether it is compressed or not. Requiring prior knowledge of image format from the user would make both the API and the usage far more complicated than having Trade::ImageData which handles both cases. On the other hand, the Image*/CompressedImage* distinction is done for easier usage and type-safe APIs in all other cases.
11 years ago
}
#ifndef DOXYGEN_GENERATING_OUTPUT
Split the Trade library out.
8 years ago
template class MAGNUM_TRADE_EXPORT ImageData<1>;
template class MAGNUM_TRADE_EXPORT ImageData<2>;
template class MAGNUM_TRADE_EXPORT ImageData<3>;
Compressed image support, part 6: Compressed* image classes. Added (now empty) AbstractCompressedImage class that inherits (now also empty) AbstractImage class. Added CompressedBufferImage, CompressedImage and CompressedImageView classes, which are just copies of BufferImage, Image and ImageView classes with format/type pair replaced by just format, but they additionally need data size parameter. Because of different use cases in Trade, the Trade::ImageData class now handles both uncompressed and compressed format, checking the API usage with runtime assertions. The reason for this is that a material could just reference a image file by ID and we need to be able to extract image of that ID without prior knowledge whether it is compressed or not. Requiring prior knowledge of image format from the user would make both the API and the usage far more complicated than having Trade::ImageData which handles both cases. On the other hand, the Image*/CompressedImage* distinction is done for easier usage and type-safe APIs in all other cases.
11 years ago
#endif
}}