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.
11541 Commits
21 Branches
19 Tags
70 MiB
Tree: a96fc85736
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'a96fc85736'
${ noResults }
magnum/src/Magnum/GL/BufferImage.cpp

190 lines
13 KiB
Raw Normal View History Unescape

Explicit instantiation of Image types. De-inlined setData() functions, as they were too heavy for inlining.
14 years ago
/*
This file is part of Magnum.
Updated copyright year.
6 years ago
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019,
Here we go again.
1 year ago
2020, 2021, 2022, 2023, 2024, 2025
It's October already?!
2 years ago
Vladimír Vondruš <mosra@centrum.cz>
Relicensing to MIT/Expat license, part 3: source files. Added license header also to shader sources. Hopefully it won't harm compilation times too much.
13 years ago
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.
Explicit instantiation of Image types. De-inlined setData() functions, as they were too heavy for inlining.
14 years ago
*/
Renamed Buffered{Image,Texture} to Buffer{Image,Texture}. Buffered* hinted that it has something to do with caching, streaming or whatever. "Buffer texture" is now also consistent with naming in specification.
14 years ago
#include "BufferImage.h"
Explicit instantiation of Image types. De-inlined setData() functions, as they were too heavy for inlining.
14 years ago
Split the OpenGL layer out, pt 1: moving files to a new location. Minimal updates (just the include guards) so Git is hopefully able to detect the rename and track the history properly. Everything except Magnum::GL doesn't compile now.
8 years ago
#include "Magnum/GL/PixelFormat.h"
De-inline Image headers, remove dependency on ImageView. This means users have to add some more #includes on their side. Sorry but it's for your own good :P
7 years ago
#include "Magnum/Implementation/ImageProperties.h"
Added NoCreate {Compressed,}BufferImage constructors. To have common API across the board.
9 years ago
Split the OpenGL layer out, pt 4: new Magnum::GL namespace. At the moment just the GL library itself w/o the tests, and without backwards compatibility aliases. The following types were left in the root namespace, despite being in the GL/ directory, as they will get moved back soon: * Image, CompressedImage and their dimensional typedefs * ImageView, CompressedImageView and their dimensional typedefs * PixelStorage Not PixelFormat etc., that one will stay in the GL namespace and a completely new PixelFormat enum will be provided in the root namespace.
8 years ago
namespace Magnum { namespace GL {
Explicit instantiation of Image types. De-inlined setData() functions, as they were too heavy for inlining.
14 years ago
If targetting exactly ES 2.0, hide everything not available there. Some target platforms supply their own OpenGL headers, thus we cannot use our own from ES 3.0 and compilation fails. On the other hand, this will be better for users as usage of unsupported features will be catched right during compilation and not at runtime.
14 years ago
#ifndef MAGNUM_TARGET_GLES2
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> BufferImage<dimensions>::BufferImage(const PixelStorage storage, const PixelFormat format, const PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::ArrayView<const void> const data, const BufferUsage usage): BufferImage{storage, format, type, size, Buffer{Buffer::TargetHint::PixelPack}, data.size()} {
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
_buffer.setData(data, usage);
Improved BufferImage API, added test. Move constructor and move assignment now behaves similarly to Image (not only the buffer but also size is swapped). Added constructor taking size + data, reordered setData() parameters to match order in Image. The old setData() function is now alias to the new one, is marked as deprecated and will be removed in future release.
13 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> BufferImage<dimensions>::BufferImage(const PixelStorage storage, const Magnum::PixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::ArrayView<const void> const data, const BufferUsage usage): BufferImage{storage, GL::pixelFormat(format), GL::pixelType(format), size, data, usage} {}
GL: store pixel size in the BufferImage instance. All other image classes do that, and thus code generally assumes that querying it is an immediate operation, not a monster switch over hundreds of values. Plus this prepares for the future internal representation that is just sizes + strides instead of the overcomplicated PixelStorage madness.
1 year ago
template<UnsignedInt dimensions> BufferImage<dimensions>::BufferImage(const PixelStorage storage, const PixelFormat format, const PixelType type, const VectorTypeFor<dimensions, Int>& size, Buffer&& buffer, const std::size_t dataSize) noexcept: _storage{storage}, _format{format}, _type{type}, _size{size}, _buffer{Utility::move(buffer)}, _pixelSize{pixelFormatSize(format, type)}, _dataSize{dataSize} {
GL: unify assertion prefix with how it's done for other constructors.
1 year ago
CORRADE_ASSERT(Magnum::Implementation::imageDataSize(*this) <= dataSize, "GL::BufferImage: data too small, got" << dataSize << "but expected at least" << Magnum::Implementation::imageDataSize(*this) << "bytes", );
Ability to create {Compressed,}BufferImage from an existing Buffer. One use case might be data reinterpreting in combination with {Compressed,}BufferImage::release().
9 years ago
}
Use Utility::move() and swap() instead of STL almost everywhere. Partially needed to avoid build breakages because Corrade itself switched as well, partially because a cleanup is always good. Done except for (STL-heavy) code that's deprecated or SceneGraph-related APIs that are still quite full of STL as well.
3 years ago
template<UnsignedInt dimensions> BufferImage<dimensions>::BufferImage(const PixelStorage storage, const Magnum::PixelFormat format, const VectorTypeFor<dimensions, Int>& size, Buffer&& buffer, const std::size_t dataSize) noexcept: BufferImage{storage, GL::pixelFormat(format), GL::pixelType(format), size, Utility::move(buffer), dataSize} {}
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
GL: store pixel size in the BufferImage instance. All other image classes do that, and thus code generally assumes that querying it is an immediate operation, not a monster switch over hundreds of values. Plus this prepares for the future internal representation that is just sizes + strides instead of the overcomplicated PixelStorage madness.
1 year ago
template<UnsignedInt dimensions> BufferImage<dimensions>::BufferImage(const PixelStorage storage, const PixelFormat format, const PixelType type): _storage{storage}, _format{format}, _type{type}, _buffer{Buffer::TargetHint::PixelPack}, _pixelSize{pixelFormatSize(format, type)}, _dataSize{} {
GL: delegate one more BufferImage constructor to reduce redundancy. The other constructors cannot be delegated, document why.
1 year ago
/* Not delegating to the (buffer&&, dataSize) constructor to avoid a size
assertion that'd happen with certain storage parameters */
}
Improved BufferImage API, added test. Move constructor and move assignment now behaves similarly to Image (not only the buffer but also size is swapped). Added constructor taking size + data, reordered setData() parameters to match order in Image. The old setData() function is now alias to the new one, is marked as deprecated and will be removed in future release.
13 years ago
GL: delegate one more BufferImage constructor to reduce redundancy. The other constructors cannot be delegated, document why.
1 year ago
template<UnsignedInt dimensions> BufferImage<dimensions>::BufferImage(const PixelStorage storage, const Magnum::PixelFormat format): BufferImage{storage, GL::pixelFormat(format), GL::pixelType(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
GL: store pixel size in the BufferImage instance. All other image classes do that, and thus code generally assumes that querying it is an immediate operation, not a monster switch over hundreds of values. Plus this prepares for the future internal representation that is just sizes + strides instead of the overcomplicated PixelStorage madness.
1 year ago
template<UnsignedInt dimensions> BufferImage<dimensions>::BufferImage(NoCreateT) noexcept: _format{PixelFormat::RGBA}, _type{PixelType::UnsignedByte}, _buffer{NoCreate}, _pixelSize{4}, _dataSize{} {}
Added NoCreate {Compressed,}BufferImage constructors. To have common API across the board.
9 years ago
GL: store pixel size in the BufferImage instance. All other image classes do that, and thus code generally assumes that querying it is an immediate operation, not a monster switch over hundreds of values. Plus this prepares for the future internal representation that is just sizes + strides instead of the overcomplicated PixelStorage madness.
1 year ago
template<UnsignedInt dimensions> BufferImage<dimensions>::BufferImage(BufferImage<dimensions>&& other) noexcept: _storage{Utility::move(other._storage)}, _format{Utility::move(other._format)}, _type{Utility::move(other._type)}, _size{Utility::move(other._size)}, _buffer{Utility::move(other._buffer)}, _pixelSize{Utility::move(other._pixelSize)}, _dataSize{Utility::move(other._dataSize)} {
De-inline Image headers, remove dependency on ImageView. This means users have to add some more #includes on their side. Sorry but it's for your own good :P
7 years ago
other._size = {};
}
template<UnsignedInt dimensions> BufferImage<dimensions>& BufferImage<dimensions>::operator=(BufferImage<dimensions>&& other) noexcept {
Use Utility::move() and swap() instead of STL almost everywhere. Partially needed to avoid build breakages because Corrade itself switched as well, partially because a cleanup is always good. Done except for (STL-heavy) code that's deprecated or SceneGraph-related APIs that are still quite full of STL as well.
3 years ago
using Utility::swap;
De-inline Image headers, remove dependency on ImageView. This means users have to add some more #includes on their side. Sorry but it's for your own good :P
7 years ago
swap(_storage, other._storage);
swap(_format, other._format);
swap(_type, other._type);
swap(_size, other._size);
swap(_buffer, other._buffer);
GL: store pixel size in the BufferImage instance. All other image classes do that, and thus code generally assumes that querying it is an immediate operation, not a monster switch over hundreds of values. Plus this prepares for the future internal representation that is just sizes + strides instead of the overcomplicated PixelStorage madness.
1 year ago
swap(_pixelSize, other._pixelSize);
De-inline Image headers, remove dependency on ImageView. This means users have to add some more #includes on their side. Sorry but it's for your own good :P
7 years ago
swap(_dataSize, other._dataSize);
return *this;
}
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);
}
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
template<UnsignedInt dimensions> void BufferImage<dimensions>::setData(const PixelStorage storage, const PixelFormat format, const PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::ArrayView<const void> const data, const BufferUsage usage) {
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
_storage = storage;
Image formats rework. Renamed the enums and enum values to be consistent with OpenGL, added integer types, fixed OpenGL ES compatibility.
14 years ago
_format = format;
Explicit instantiation of Image types. De-inlined setData() functions, as they were too heavy for inlining.
14 years ago
_type = type;
Distinguish dimensions (1D, 2D, 3D) from image size.
14 years ago
_size = size;
GL: store pixel size in the BufferImage instance. All other image classes do that, and thus code generally assumes that querying it is an immediate operation, not a monster switch over hundreds of values. Plus this prepares for the future internal representation that is just sizes + strides instead of the overcomplicated PixelStorage madness.
1 year ago
_pixelSize = pixelFormatSize(format, type);
Ability to reset BufferImage formats without reallocating the buffer. Will be used in various image getters to avoid overwriting previous data in combination with pixel storage skip parameters.
11 years ago
/* Keep the old storage if zero-sized nullptr buffer was passed */
if(data.data() == nullptr && data.size() == 0)
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(Magnum::Implementation::imageDataSize(*this) <= _dataSize, "GL::BufferImage::setData(): current storage too small, got" << _dataSize << "but expected at least" << Magnum::Implementation::imageDataSize(*this) << "bytes", );
Ability to reset BufferImage formats without reallocating the buffer. Will be used in various image getters to avoid overwriting previous data in combination with pixel storage skip parameters.
11 years ago
else {
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(Magnum::Implementation::imageDataSize(*this) <= data.size(), "GL::BufferImage::setData(): data too small, got" << data.size() << "but expected at least" << Magnum::Implementation::imageDataSize(*this) << "bytes", );
Ability to reset BufferImage formats without reallocating the buffer. Will be used in various image getters to avoid overwriting previous data in combination with pixel storage skip parameters.
11 years ago
_buffer.setData(data, usage);
_dataSize = data.size();
}
Explicit instantiation of Image types. De-inlined setData() functions, as they were too heavy for inlining.
14 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> void BufferImage<dimensions>::setData(const PixelStorage storage, const Magnum::PixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::ArrayView<const void> const data, const BufferUsage usage) {
setData(storage, GL::pixelFormat(format), GL::pixelType(format), size, data, usage);
}
template<UnsignedInt dimensions> CompressedBufferImage<dimensions>::CompressedBufferImage(const CompressedPixelStorage storage, const CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, const Containers::ArrayView<const void> data, const BufferUsage usage): CompressedBufferImage{storage, format, size, Buffer{Buffer::TargetHint::PixelPack}, data.size()} {
Store block size properties in compressed images. Similarly like pixel size is stored in uncompressed images, block size makes it possible to perform size checks on passed data, slice the images and so on. It only took over a decade to get that done. The block properties coming from CompressedPixelStorage are currently expected to be either not set at all or exactly match what's stored in the image for given format. The PixelStorage will get eventually deprecated in favor of a simpler and more flexible representation, but that's another big chunk of work so it's first done like this. The GL library tests currently blow up on various assertions and it isn't yet updated to make use of the known format properties instead of querying them from GL. That'll be done in the following commits.
10 months ago
/* Size and block properties checks done in the delegated-to constructor
already */
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
_buffer.setData(data, usage);
}
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> CompressedBufferImage<dimensions>::CompressedBufferImage(const CompressedPixelStorage storage, const Magnum::CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, const Containers::ArrayView<const void> data, const BufferUsage usage): CompressedBufferImage{storage, compressedPixelFormat(format), size, data, usage} {}
Store block size properties in compressed images. Similarly like pixel size is stored in uncompressed images, block size makes it possible to perform size checks on passed data, slice the images and so on. It only took over a decade to get that done. The block properties coming from CompressedPixelStorage are currently expected to be either not set at all or exactly match what's stored in the image for given format. The PixelStorage will get eventually deprecated in favor of a simpler and more flexible representation, but that's another big chunk of work so it's first done like this. The GL library tests currently blow up on various assertions and it isn't yet updated to make use of the known format properties instead of querying them from GL. That'll be done in the following commits.
10 months ago
template<UnsignedInt dimensions> CompressedBufferImage<dimensions>::CompressedBufferImage(const CompressedPixelStorage storage, const CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, Buffer&& buffer, const std::size_t dataSize) noexcept: _storage{storage}, _format{format}, _blockSize{Vector3ub(compressedPixelFormatBlockSize(format))}, _blockDataSize{UnsignedByte(compressedPixelFormatBlockDataSize(format))}, _size{size}, _buffer{Utility::move(buffer)}, _dataSize{dataSize} {
#ifndef CORRADE_NO_ASSERT
Magnum::Implementation::checkBlockPropertiesForStorage("GL::CompressedBufferImage:", Vector3i{_blockSize}, _blockDataSize, storage);
CORRADE_ASSERT(Magnum::Implementation::compressedImageDataSize(*this) <= dataSize, "GL::CompressedBufferImage: data too small, got" << dataSize << "but expected at least" << Magnum::Implementation::compressedImageDataSize(*this) << "bytes", );
#endif
}
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
Use Utility::move() and swap() instead of STL almost everywhere. Partially needed to avoid build breakages because Corrade itself switched as well, partially because a cleanup is always good. Done except for (STL-heavy) code that's deprecated or SceneGraph-related APIs that are still quite full of STL as well.
3 years ago
template<UnsignedInt dimensions> CompressedBufferImage<dimensions>::CompressedBufferImage(const CompressedPixelStorage storage, const Magnum::CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, Buffer&& buffer, const std::size_t dataSize) noexcept: CompressedBufferImage{storage, compressedPixelFormat(format), size, Utility::move(buffer), dataSize} {}
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
Store block size properties in compressed images. Similarly like pixel size is stored in uncompressed images, block size makes it possible to perform size checks on passed data, slice the images and so on. It only took over a decade to get that done. The block properties coming from CompressedPixelStorage are currently expected to be either not set at all or exactly match what's stored in the image for given format. The PixelStorage will get eventually deprecated in favor of a simpler and more flexible representation, but that's another big chunk of work so it's first done like this. The GL library tests currently blow up on various assertions and it isn't yet updated to make use of the known format properties instead of querying them from GL. That'll be done in the following commits.
10 months ago
template<UnsignedInt dimensions> CompressedBufferImage<dimensions>::CompressedBufferImage(const CompressedPixelStorage storage): _storage{storage}, _format{}, _blockDataSize{}, _buffer{Buffer::TargetHint::PixelPack}, _dataSize{} {
CORRADE_ASSERT(storage.compressedBlockSize() == Vector3i{},
"GL::CompressedBufferImage: expected pixel storage block size to not be set at all but got" << Debug::packed << storage.compressedBlockSize(), );
CORRADE_ASSERT(!storage.compressedBlockDataSize(),
"GL::CompressedBufferImage: expected pixel storage block data size to not be set at all but got" << storage.compressedBlockDataSize(), );
GL: delegate one more BufferImage constructor to reduce redundancy. The other constructors cannot be delegated, document why.
1 year ago
}
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
Store block size properties in compressed images. Similarly like pixel size is stored in uncompressed images, block size makes it possible to perform size checks on passed data, slice the images and so on. It only took over a decade to get that done. The block properties coming from CompressedPixelStorage are currently expected to be either not set at all or exactly match what's stored in the image for given format. The PixelStorage will get eventually deprecated in favor of a simpler and more flexible representation, but that's another big chunk of work so it's first done like this. The GL library tests currently blow up on various assertions and it isn't yet updated to make use of the known format properties instead of querying them from GL. That'll be done in the following commits.
10 months ago
template<UnsignedInt dimensions> CompressedBufferImage<dimensions>::CompressedBufferImage(NoCreateT) noexcept: _format{}, _blockDataSize{}, _buffer{NoCreate}, _dataSize{} {}
Added NoCreate {Compressed,}BufferImage constructors. To have common API across the board.
9 years ago
Store block size properties in compressed images. Similarly like pixel size is stored in uncompressed images, block size makes it possible to perform size checks on passed data, slice the images and so on. It only took over a decade to get that done. The block properties coming from CompressedPixelStorage are currently expected to be either not set at all or exactly match what's stored in the image for given format. The PixelStorage will get eventually deprecated in favor of a simpler and more flexible representation, but that's another big chunk of work so it's first done like this. The GL library tests currently blow up on various assertions and it isn't yet updated to make use of the known format properties instead of querying them from GL. That'll be done in the following commits.
10 months ago
template<UnsignedInt dimensions> CompressedBufferImage<dimensions>::CompressedBufferImage(CompressedBufferImage<dimensions>&& other) noexcept: _storage{other._storage}, _format{other._format}, _blockSize{other._blockSize}, _blockDataSize{other._blockDataSize}, _size{other._size}, _buffer{Utility::move(other._buffer)}, _dataSize{other._dataSize} {
De-inline Image headers, remove dependency on ImageView. This means users have to add some more #includes on their side. Sorry but it's for your own good :P
7 years ago
other._size = {};
other._dataSize = {};
}
template<UnsignedInt dimensions> CompressedBufferImage<dimensions>& CompressedBufferImage<dimensions>::operator=(CompressedBufferImage<dimensions>&& other) noexcept {
Use Utility::move() and swap() instead of STL almost everywhere. Partially needed to avoid build breakages because Corrade itself switched as well, partially because a cleanup is always good. Done except for (STL-heavy) code that's deprecated or SceneGraph-related APIs that are still quite full of STL as well.
3 years ago
using Utility::swap;
De-inline Image headers, remove dependency on ImageView. This means users have to add some more #includes on their side. Sorry but it's for your own good :P
7 years ago
swap(_storage, other._storage);
swap(_format, other._format);
Store block size properties in compressed images. Similarly like pixel size is stored in uncompressed images, block size makes it possible to perform size checks on passed data, slice the images and so on. It only took over a decade to get that done. The block properties coming from CompressedPixelStorage are currently expected to be either not set at all or exactly match what's stored in the image for given format. The PixelStorage will get eventually deprecated in favor of a simpler and more flexible representation, but that's another big chunk of work so it's first done like this. The GL library tests currently blow up on various assertions and it isn't yet updated to make use of the known format properties instead of querying them from GL. That'll be done in the following commits.
10 months ago
swap(_blockSize, other._blockSize);
swap(_blockDataSize, other._blockDataSize);
De-inline Image headers, remove dependency on ImageView. This means users have to add some more #includes on their side. Sorry but it's for your own good :P
7 years ago
swap(_size, other._size);
swap(_buffer, other._buffer);
swap(_dataSize, other._dataSize);
return *this;
}
template<UnsignedInt dimensions> std::pair<VectorTypeFor<dimensions, std::size_t>, VectorTypeFor<dimensions, std::size_t>> CompressedBufferImage<dimensions>::dataProperties() const {
return Magnum::Implementation::compressedImageDataProperties<dimensions>(*this);
}
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> void CompressedBufferImage<dimensions>::setData(const CompressedPixelStorage storage, const CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, const Containers::ArrayView<const void> data, const BufferUsage usage) {
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
_storage = storage;
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
_format = format;
Store block size properties in compressed images. Similarly like pixel size is stored in uncompressed images, block size makes it possible to perform size checks on passed data, slice the images and so on. It only took over a decade to get that done. The block properties coming from CompressedPixelStorage are currently expected to be either not set at all or exactly match what's stored in the image for given format. The PixelStorage will get eventually deprecated in favor of a simpler and more flexible representation, but that's another big chunk of work so it's first done like this. The GL library tests currently blow up on various assertions and it isn't yet updated to make use of the known format properties instead of querying them from GL. That'll be done in the following commits.
10 months ago
_blockSize = Vector3ub(compressedPixelFormatBlockSize(format));
_blockDataSize = UnsignedByte(compressedPixelFormatBlockDataSize(format));
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
_size = size;
Store block size properties in compressed images. Similarly like pixel size is stored in uncompressed images, block size makes it possible to perform size checks on passed data, slice the images and so on. It only took over a decade to get that done. The block properties coming from CompressedPixelStorage are currently expected to be either not set at all or exactly match what's stored in the image for given format. The PixelStorage will get eventually deprecated in favor of a simpler and more flexible representation, but that's another big chunk of work so it's first done like this. The GL library tests currently blow up on various assertions and it isn't yet updated to make use of the known format properties instead of querying them from GL. That'll be done in the following commits.
10 months ago
#ifndef CORRADE_NO_ASSERT
Magnum::Implementation::checkBlockPropertiesForStorage("GL::CompressedBufferImage::setData():", Vector3i{_blockSize}, _blockDataSize, storage);
#endif
GL: make CompressedBufferImage and BufferImage::setData() work the same. The uncompressed variant preserves the buffer contents if passed an empty view, which was done in 5ee461bdbe1fb17082a15a76b0a87c0349a1ef85 (2015!) but no corresponding change was ever done for the compressed variant. So let's make both do the same, and actually test the code path, which wasn't done until now either.
1 year ago
/* Keep the old storage if zero-sized nullptr buffer was passed */
Store block size properties in compressed images. Similarly like pixel size is stored in uncompressed images, block size makes it possible to perform size checks on passed data, slice the images and so on. It only took over a decade to get that done. The block properties coming from CompressedPixelStorage are currently expected to be either not set at all or exactly match what's stored in the image for given format. The PixelStorage will get eventually deprecated in favor of a simpler and more flexible representation, but that's another big chunk of work so it's first done like this. The GL library tests currently blow up on various assertions and it isn't yet updated to make use of the known format properties instead of querying them from GL. That'll be done in the following commits.
10 months ago
if(data.data() == nullptr && data.size() == 0) {
CORRADE_ASSERT(Magnum::Implementation::compressedImageDataSize(*this) <= _dataSize, "GL::CompressedBufferImage::setData(): current storage too small, got" << _dataSize << "but expected at least" << Magnum::Implementation::compressedImageDataSize(*this) << "bytes", );
} else {
CORRADE_ASSERT(Magnum::Implementation::compressedImageDataSize(*this) <= data.size(), "GL::CompressedBufferImage::setData(): data too small, got" << data.size() << "but expected at least" << Magnum::Implementation::compressedImageDataSize(*this) << "bytes", );
GL: make CompressedBufferImage and BufferImage::setData() work the same. The uncompressed variant preserves the buffer contents if passed an empty view, which was done in 5ee461bdbe1fb17082a15a76b0a87c0349a1ef85 (2015!) but no corresponding change was ever done for the compressed variant. So let's make both do the same, and actually test the code path, which wasn't done until now either.
1 year ago
_buffer.setData(data, usage);
_dataSize = data.size();
}
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
template<UnsignedInt dimensions> void CompressedBufferImage<dimensions>::setData(const CompressedPixelStorage storage, const Magnum::CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, const Containers::ArrayView<const void> data, const BufferUsage usage) {
setData(storage, compressedPixelFormat(format), size, data, usage);
}
Added {Compressed,}BufferImage::release(). To mirror the API in other Image classes.
9 years ago
template<UnsignedInt dimensions> Buffer BufferImage<dimensions>::release() {
_size = {};
_dataSize = {};
Use Utility::move() and swap() instead of STL almost everywhere. Partially needed to avoid build breakages because Corrade itself switched as well, partially because a cleanup is always good. Done except for (STL-heavy) code that's deprecated or SceneGraph-related APIs that are still quite full of STL as well.
3 years ago
return Utility::move(_buffer);
Added {Compressed,}BufferImage::release(). To mirror the API in other Image classes.
9 years ago
}
template<UnsignedInt dimensions> Buffer CompressedBufferImage<dimensions>::release() {
_size = {};
_dataSize = {};
Use Utility::move() and swap() instead of STL almost everywhere. Partially needed to avoid build breakages because Corrade itself switched as well, partially because a cleanup is always good. Done except for (STL-heavy) code that's deprecated or SceneGraph-related APIs that are still quite full of STL as well.
3 years ago
return Utility::move(_buffer);
Added {Compressed,}BufferImage::release(). To mirror the API in other Image classes.
9 years ago
}
Split the OpenGL layer out, pt 1: moving files to a new location. Minimal updates (just the include guards) so Git is hopefully able to detect the rename and track the history properly. Everything except Magnum::GL doesn't compile now.
8 years ago
template class MAGNUM_GL_EXPORT BufferImage<1>;
template class MAGNUM_GL_EXPORT BufferImage<2>;
template class MAGNUM_GL_EXPORT BufferImage<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
Split the OpenGL layer out, pt 1: moving files to a new location. Minimal updates (just the include guards) so Git is hopefully able to detect the rename and track the history properly. Everything except Magnum::GL doesn't compile now.
8 years ago
template class MAGNUM_GL_EXPORT CompressedBufferImage<1>;
template class MAGNUM_GL_EXPORT CompressedBufferImage<2>;
template class MAGNUM_GL_EXPORT CompressedBufferImage<3>;
If targetting exactly ES 2.0, hide everything not available there. Some target platforms supply their own OpenGL headers, thus we cannot use our own from ES 3.0 and compilation fails. On the other hand, this will be better for users as usage of unsupported features will be catched right during compilation and not at runtime.
14 years ago
#endif
Explicit instantiation of Image types. De-inlined setData() functions, as they were too heavy for inlining.
14 years ago
Split the OpenGL layer out, pt 4: new Magnum::GL namespace. At the moment just the GL library itself w/o the tests, and without backwards compatibility aliases. The following types were left in the root namespace, despite being in the GL/ directory, as they will get moved back soon: * Image, CompressedImage and their dimensional typedefs * ImageView, CompressedImageView and their dimensional typedefs * PixelStorage Not PixelFormat etc., that one will stay in the GL namespace and a completely new PixelFormat enum will be provided in the root namespace.
8 years ago
}}