/*
This file is part of Magnum .
Copyright © 2010 , 2011 , 2012 , 2013 , 2014 , 2015 , 2016 , 2017 , 2018 , 2019
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"
# include <Corrade/Containers/StridedArrayView.h>
# include "Magnum/ImageView.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"
# include "Magnum/Implementation/ImageProperties.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
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 } {
CORRADE_ASSERT ( Implementation : : imageDataSize ( * this ) < = _data . size ( ) , " Trade::ImageData::ImageData(): data too small, got " < < _data . size ( ) < < " but expected at least " < < Implementation : : imageDataSize ( * this ) < < " bytes " , ) ;
}
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 } { }
template < UnsignedInt dimensions > ImageData < dimensions > : : ImageData ( ImageData < dimensions > & & other ) noexcept : _compressed { std : : move ( other . _compressed ) } , _size { std : : move ( other . _size ) } , _data { std : : move ( other . _data ) } , _importerState { std : : move ( other . _importerState ) } {
if ( _compressed ) {
new ( & _compressedStorage ) CompressedPixelStorage { std : : move ( other . _compressedStorage ) } ;
_compressedFormat = std : : move ( other . _compressedFormat ) ;
}
else {
new ( & _storage ) PixelStorage { std : : move ( other . _storage ) } ;
_format = std : : move ( other . _format ) ;
_formatExtra = std : : move ( other . _formatExtra ) ;
_pixelSize = std : : move ( other . _pixelSize ) ;
}
other . _size = { } ;
}
template < UnsignedInt dimensions > ImageData < dimensions > : : ImageData ( ImageData < dimensions > & & other , const void * const importerState ) noexcept : ImageData { std : : move ( other ) } {
_importerState = importerState ;
}
template < UnsignedInt dimensions > ImageData < dimensions > & ImageData < dimensions > : : operator = ( ImageData < dimensions > & & other ) noexcept {
using std : : swap ;
swap ( _compressed , other . _compressed ) ;
if ( _compressed ) {
swap ( _compressedStorage , other . _compressedStorage ) ;
swap ( _compressedFormat , other . _compressedFormat ) ;
}
else {
swap ( _storage , other . _storage ) ;
swap ( _format , other . _format ) ;
}
swap ( _formatExtra , other . _formatExtra ) ;
swap ( _pixelSize , other . _pixelSize ) ;
swap ( _size , other . _size ) ;
swap ( _data , other . _data ) ;
swap ( _importerState , other . _importerState ) ;
return * this ;
}
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 {
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 ;
}
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 {
CORRADE_ASSERT ( _compressed , " Trade::ImageData::compressedFormat(): the image is not compressed " , { } ) ;
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 {
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 ;
}
template < UnsignedInt dimensions > std : : pair < VectorTypeFor < dimensions , std : : size_t > , VectorTypeFor < dimensions , std : : size_t > > ImageData < dimensions > : : dataProperties ( ) const {
CORRADE_ASSERT ( ! _compressed , " Trade::ImageData::dataProperties(): the image is compressed " , { } ) ;
return Implementation : : imageDataProperties < dimensions > ( * this ) ;
}
template < UnsignedInt dimensions > Containers : : StridedArrayView < dimensions + 1 , char > ImageData < dimensions > : : pixels ( ) {
CORRADE_ASSERT ( ! _compressed , " Trade::ImageData::pixels(): the image is compressed " , { } ) ;
return Implementation : : imagePixelView < dimensions , char > ( * this ) ;
}
template < UnsignedInt dimensions > Containers : : StridedArrayView < dimensions + 1 , const char > ImageData < dimensions > : : pixels ( ) const {
CORRADE_ASSERT ( ! _compressed , " Trade::ImageData::pixels(): the image is compressed " , { } ) ;
return Implementation : : imagePixelView < dimensions , const char > ( * this ) ;
}
template < UnsignedInt dimensions > ImageData < dimensions > : : operator BasicMutableImageView < dimensions > ( ) {
CORRADE_ASSERT ( ! _compressed , " Trade::ImageData: the image is compressed " , ( BasicMutableImageView < dimensions > { _storage , _format , _formatExtra , _pixelSize , _size } ) ) ;
return BasicMutableImageView < dimensions > { _storage , _format , _formatExtra , _pixelSize , _size , _data } ;
}
template < UnsignedInt dimensions > ImageData < dimensions > : : operator BasicImageView < dimensions > ( ) const {
CORRADE_ASSERT ( ! _compressed , " Trade::ImageData: the image is compressed " , ( BasicImageView < dimensions > { _storage , _format , _formatExtra , _pixelSize , _size } ) ) ;
return BasicImageView < dimensions > { _storage , _format , _formatExtra , _pixelSize , _size , _data } ;
}
template < UnsignedInt dimensions > ImageData < dimensions > : : operator BasicMutableCompressedImageView < dimensions > ( ) {
CORRADE_ASSERT ( _compressed , " Trade::ImageData: the image is not compressed " , ( BasicMutableCompressedImageView < dimensions > { _compressedStorage , _compressedFormat , _size } ) ) ;
return BasicMutableCompressedImageView < dimensions > {
_compressedStorage ,
_compressedFormat , _size , _data } ;
}
template < UnsignedInt dimensions > ImageData < dimensions > : : operator BasicCompressedImageView < dimensions > ( ) const {
CORRADE_ASSERT ( _compressed , " Trade::ImageData: the image is not compressed " , ( BasicCompressedImageView < dimensions > { _compressedStorage , _compressedFormat , _size } ) ) ;
return BasicCompressedImageView < dimensions > {
_compressedStorage ,
_compressedFormat , _size , _data } ;
}
template < UnsignedInt dimensions > Containers : : Array < char > ImageData < dimensions > : : release ( ) {
Containers : : Array < char > data { std : : move ( _data ) } ;
_size = { } ;
return data ;
}
# ifndef DOXYGEN_GENERATING_OUTPUT
template class MAGNUM_TRADE_EXPORT ImageData < 1 > ;
template class MAGNUM_TRADE_EXPORT ImageData < 2 > ;
template class MAGNUM_TRADE_EXPORT ImageData < 3 > ;
# endif
} }
