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.
7764 Commits
21 Branches
19 Tags
70 MiB
Tree: 74c75178de
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '74c75178de'
${ noResults }
magnum/doc/snippets/MagnumTrade.cpp

536 lines
17 KiB
Raw Normal View History Unescape

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
/*
This file is part of Magnum.
Updated copyright year.
7 years ago
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019
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
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.
*/
Trade: support for file loading callbacks in AbstractImporter.
8 years ago
#include <unordered_map>
Removed std::optional backwards compatibility. This was a dirty mess. Good riddance. Also removing the include from the header now, as it has a forward declaration and thus is not needed.
7 years ago
#include <Corrade/Containers/Optional.h>
Trade: support for file loading callbacks in AbstractImporter.
8 years ago
#include <Corrade/Utility/Directory.h>
doc/snippets: adapt to Corrade header cleanup.
7 years ago
#include <Corrade/Utility/Resource.h>
Trade: support for file loading callbacks in AbstractImporter.
8 years ago
Move Trade::ImporterFileCallbackPolicy to InputFileCallbackPolicy. It'll get used outside of the root namespace and since the callbacks tend to be quite complex, it would be silly to require users to implement one callback for Trade, one for Text and one for Audio, for example.
7 years ago
#include "Magnum/FileCallback.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/ImageView.h"
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
#include "Magnum/Mesh.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"
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
#include "Magnum/MeshTools/Interleave.h"
Trade: document AnimationData usage. This is the last non-obvious thing that needs to be documented in order to make the API usable.
8 years ago
#include "Magnum/Animation/Player.h"
Trade: document how MeshData can be further transformed.
8 years ago
#include "Magnum/MeshTools/Transform.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/Trade/AbstractImporter.h"
Trade: document AnimationData usage. This is the last non-obvious thing that needs to be documented in order to make the API usable.
8 years ago
#include "Magnum/Trade/AnimationData.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/Trade/ImageData.h"
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
#include "Magnum/Trade/MeshData.h"
Trade: support separate translation/rotation/scaling in ObjectData. Doesn't make any backwards-incompatible change -- plugins can still export the transformation as matrix and users can still access the combined one even if separate transformations are used. Yay!
8 years ago
#include "Magnum/Trade/ObjectData2D.h"
#include "Magnum/Trade/ObjectData3D.h"
Trade: actually create some useful docs for AbstractImporter.
8 years ago
#include "Magnum/Trade/PhongMaterialData.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
#ifdef MAGNUM_TARGET_GL
#include "Magnum/GL/Texture.h"
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
#include "Magnum/GL/Mesh.h"
Trade: high-level docs for the MeshData class.
6 years ago
#include "Magnum/MeshTools/Compile.h"
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
#include "Magnum/Shaders/Phong.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
#endif
Trade: high-level docs for the MeshData class.
6 years ago
#ifdef MAGNUM_TARGET_VK
#include "Magnum/Vk/Vulkan.h"
#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
Trade, MeshTools: deprecate MeshDataXD and everything that uses it.
6 years ago
#ifdef MAGNUM_BUILD_DEPRECATED
#define _MAGNUM_NO_DEPRECATED_MESHDATA /* So it doesn't yell here */
#include "Magnum/Trade/MeshData2D.h"
#include "Magnum/Trade/MeshData3D.h"
#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
using namespace Magnum;
using namespace Magnum::Math::Literals;
int main() {
Trade: actually create some useful docs for AbstractImporter.
8 years ago
{
/* [AbstractImporter-usage] */
PluginManager::Manager<Trade::AbstractImporter> manager;
Get rid of std::unique_ptr.
7 years ago
Containers::Pointer<Trade::AbstractImporter> importer =
Trade: actually create some useful docs for AbstractImporter.
8 years ago
manager.loadAndInstantiate("AnyImageImporter");
if(!importer || !importer->openFile("image.png"))
Fatal{} << "Can't open image.png with AnyImageImporter";
Containers::Optional<Trade::ImageData2D> image = importer->image2D(0);
if(!image) Fatal{} << "Importing the image failed";
// use the image ...
/* [AbstractImporter-usage] */
}
#if defined(CORRADE_TARGET_UNIX) || (defined(CORRADE_TARGET_WINDOWS) && !defined(CORRADE_TARGET_WINDOWS_RT))
{
Get rid of std::unique_ptr.
7 years ago
Containers::Pointer<Trade::AbstractImporter> importer;
Trade: actually create some useful docs for AbstractImporter.
8 years ago
/* [AbstractImporter-usage-callbacks] */
struct Data {
std::unordered_map<std::string,
Containers::Array<const char, Utility::Directory::MapDeleter>> files;
} data;
importer->setFileCallback([](const std::string& filename,
Move Trade::ImporterFileCallbackPolicy to InputFileCallbackPolicy. It'll get used outside of the root namespace and since the callbacks tend to be quite complex, it would be silly to require users to implement one callback for Trade, one for Text and one for Audio, for example.
7 years ago
InputFileCallbackPolicy policy, Data& data)
Trade: redesign importer file callbacks. The original implementation had a few problems: - If a file callback was set, openFile() was unconditionally calling right into doOpenData(), making it impossible for the importer to know the original path for correctly supplying paths to additional files. Now, if the importer supports Feature::FileCallback, doOpenFile() is always called. It's also possible for the importer to save the path and then just delegate to the base doOpenFile() implementation -- it will handle the file callbacks correctly too. - If the importer supported neither FileCallback nor OpenData and callbacks were set, the original doOpenFile() implementation was called without any warning or anything, doing silently a bad thing. Now in this case setFileCallbacks() asserts -- programmer has to check for feature support first. - It was not possible for the file callback to indicate file opening failure -- in general, empty files are valid, so a nullptr ArrayView is also a valid file. Now the callback return an Optional instead.
8 years ago
-> Containers::Optional<Containers::ArrayView<const char>>
{
Trade: actually create some useful docs for AbstractImporter.
8 years ago
auto found = data.files.find(filename);
/* Discard the memory mapping, if not needed anymore */
Move Trade::ImporterFileCallbackPolicy to InputFileCallbackPolicy. It'll get used outside of the root namespace and since the callbacks tend to be quite complex, it would be silly to require users to implement one callback for Trade, one for Text and one for Audio, for example.
7 years ago
if(policy == InputFileCallbackPolicy::Close) {
Trade: actually create some useful docs for AbstractImporter.
8 years ago
if(found != data.files.end()) data.files.erase(found);
Trade: redesign importer file callbacks. The original implementation had a few problems: - If a file callback was set, openFile() was unconditionally calling right into doOpenData(), making it impossible for the importer to know the original path for correctly supplying paths to additional files. Now, if the importer supports Feature::FileCallback, doOpenFile() is always called. It's also possible for the importer to save the path and then just delegate to the base doOpenFile() implementation -- it will handle the file callbacks correctly too. - If the importer supported neither FileCallback nor OpenData and callbacks were set, the original doOpenFile() implementation was called without any warning or anything, doing silently a bad thing. Now in this case setFileCallbacks() asserts -- programmer has to check for feature support first. - It was not possible for the file callback to indicate file opening failure -- in general, empty files are valid, so a nullptr ArrayView is also a valid file. Now the callback return an Optional instead.
8 years ago
return {};
Trade: actually create some useful docs for AbstractImporter.
8 years ago
}
/* Load if not there yet */
if(found == data.files.end()) found = data.files.emplace(
filename, Utility::Directory::mapRead(filename)).first;
Trade: redesign importer file callbacks. The original implementation had a few problems: - If a file callback was set, openFile() was unconditionally calling right into doOpenData(), making it impossible for the importer to know the original path for correctly supplying paths to additional files. Now, if the importer supports Feature::FileCallback, doOpenFile() is always called. It's also possible for the importer to save the path and then just delegate to the base doOpenFile() implementation -- it will handle the file callbacks correctly too. - If the importer supported neither FileCallback nor OpenData and callbacks were set, the original doOpenFile() implementation was called without any warning or anything, doing silently a bad thing. Now in this case setFileCallbacks() asserts -- programmer has to check for feature support first. - It was not possible for the file callback to indicate file opening failure -- in general, empty files are valid, so a nullptr ArrayView is also a valid file. Now the callback return an Optional instead.
8 years ago
return Containers::arrayView(found->second);
Trade: actually create some useful docs for AbstractImporter.
8 years ago
}, data);
importer->openFile("scene.gltf"); // memory-maps all files
/* [AbstractImporter-usage-callbacks] */
}
#endif
{
Get rid of std::unique_ptr.
7 years ago
Containers::Pointer<Trade::AbstractImporter> importer;
Trade: actually create some useful docs for AbstractImporter.
8 years ago
Float shininess;
/* [AbstractImporter-usage-cast] */
Get rid of std::unique_ptr.
7 years ago
Containers::Pointer<Trade::AbstractMaterialData> data = importer->material(12);
Trade: actually create some useful docs for AbstractImporter.
8 years ago
if(data && data->type() == Trade::MaterialType::Phong) {
auto& phong = static_cast<Trade::PhongMaterialData&>(*data);
shininess = phong.shininess();
// ...
}
/* [AbstractImporter-usage-cast] */
static_cast<void>(shininess);
}
Trade: support for file loading callbacks in AbstractImporter.
8 years ago
{
Get rid of std::unique_ptr.
7 years ago
Containers::Pointer<Trade::AbstractImporter> importer;
Trade: support for file loading callbacks in AbstractImporter.
8 years ago
/* [AbstractImporter-setFileCallback] */
importer->setFileCallback([](const std::string& filename,
Move Trade::ImporterFileCallbackPolicy to InputFileCallbackPolicy. It'll get used outside of the root namespace and since the callbacks tend to be quite complex, it would be silly to require users to implement one callback for Trade, one for Text and one for Audio, for example.
7 years ago
InputFileCallbackPolicy, void*) {
Trade: support for file loading callbacks in AbstractImporter.
8 years ago
Utility::Resource rs("data");
Trade: redesign importer file callbacks. The original implementation had a few problems: - If a file callback was set, openFile() was unconditionally calling right into doOpenData(), making it impossible for the importer to know the original path for correctly supplying paths to additional files. Now, if the importer supports Feature::FileCallback, doOpenFile() is always called. It's also possible for the importer to save the path and then just delegate to the base doOpenFile() implementation -- it will handle the file callbacks correctly too. - If the importer supported neither FileCallback nor OpenData and callbacks were set, the original doOpenFile() implementation was called without any warning or anything, doing silently a bad thing. Now in this case setFileCallbacks() asserts -- programmer has to check for feature support first. - It was not possible for the file callback to indicate file opening failure -- in general, empty files are valid, so a nullptr ArrayView is also a valid file. Now the callback return an Optional instead.
8 years ago
return Containers::optional(rs.getRaw(filename));
Trade: support for file loading callbacks in AbstractImporter.
8 years ago
});
/* [AbstractImporter-setFileCallback] */
}
{
Get rid of std::unique_ptr.
7 years ago
Containers::Pointer<Trade::AbstractImporter> importer;
Trade: support for file loading callbacks in AbstractImporter.
8 years ago
/* [AbstractImporter-setFileCallback-template] */
struct Data {
std::unordered_map<std::string, Containers::Array<char>> files;
} data;
importer->setFileCallback([](const std::string& filename,
Move Trade::ImporterFileCallbackPolicy to InputFileCallbackPolicy. It'll get used outside of the root namespace and since the callbacks tend to be quite complex, it would be silly to require users to implement one callback for Trade, one for Text and one for Audio, for example.
7 years ago
InputFileCallbackPolicy, Data& data)
Trade: redesign importer file callbacks. The original implementation had a few problems: - If a file callback was set, openFile() was unconditionally calling right into doOpenData(), making it impossible for the importer to know the original path for correctly supplying paths to additional files. Now, if the importer supports Feature::FileCallback, doOpenFile() is always called. It's also possible for the importer to save the path and then just delegate to the base doOpenFile() implementation -- it will handle the file callbacks correctly too. - If the importer supported neither FileCallback nor OpenData and callbacks were set, the original doOpenFile() implementation was called without any warning or anything, doing silently a bad thing. Now in this case setFileCallbacks() asserts -- programmer has to check for feature support first. - It was not possible for the file callback to indicate file opening failure -- in general, empty files are valid, so a nullptr ArrayView is also a valid file. Now the callback return an Optional instead.
8 years ago
-> Containers::Optional<Containers::ArrayView<const char>>
{
Trade: support for file loading callbacks in AbstractImporter.
8 years ago
auto found = data.files.find(filename);
Trade: redesign importer file callbacks. The original implementation had a few problems: - If a file callback was set, openFile() was unconditionally calling right into doOpenData(), making it impossible for the importer to know the original path for correctly supplying paths to additional files. Now, if the importer supports Feature::FileCallback, doOpenFile() is always called. It's also possible for the importer to save the path and then just delegate to the base doOpenFile() implementation -- it will handle the file callbacks correctly too. - If the importer supported neither FileCallback nor OpenData and callbacks were set, the original doOpenFile() implementation was called without any warning or anything, doing silently a bad thing. Now in this case setFileCallbacks() asserts -- programmer has to check for feature support first. - It was not possible for the file callback to indicate file opening failure -- in general, empty files are valid, so a nullptr ArrayView is also a valid file. Now the callback return an Optional instead.
8 years ago
if(found == data.files.end()) {
Adapted to Corrade changes.
7 years ago
if(!Utility::Directory::exists(filename))
Trade: redesign importer file callbacks. The original implementation had a few problems: - If a file callback was set, openFile() was unconditionally calling right into doOpenData(), making it impossible for the importer to know the original path for correctly supplying paths to additional files. Now, if the importer supports Feature::FileCallback, doOpenFile() is always called. It's also possible for the importer to save the path and then just delegate to the base doOpenFile() implementation -- it will handle the file callbacks correctly too. - If the importer supported neither FileCallback nor OpenData and callbacks were set, the original doOpenFile() implementation was called without any warning or anything, doing silently a bad thing. Now in this case setFileCallbacks() asserts -- programmer has to check for feature support first. - It was not possible for the file callback to indicate file opening failure -- in general, empty files are valid, so a nullptr ArrayView is also a valid file. Now the callback return an Optional instead.
8 years ago
return Containers::NullOpt;
found = data.files.emplace(filename, Utility::Directory::read(filename)).first;
}
Trade: support for file loading callbacks in AbstractImporter.
8 years ago
return Containers::ArrayView<const char>{found->second};
}, data);
/* [AbstractImporter-setFileCallback-template] */
}
Trade: document AnimationData usage. This is the last non-obvious thing that needs to be documented in order to make the API usable.
8 years ago
{
UnsignedInt id{};
Get rid of std::unique_ptr.
7 years ago
Containers::Pointer<Trade::AbstractImporter> importer;
Trade: document AnimationData usage. This is the last non-obvious thing that needs to be documented in order to make the API usable.
8 years ago
/* [AnimationData-usage] */
Containers::Optional<Trade::AnimationData> data = importer->animation(id);
Animation::Player<Float> player;
Containers::Array<Vector3> positions; /* Translations for all objects */
for(UnsignedInt i = 0; i != data->trackCount(); ++i) {
Trade: change animation track target to target type and target ID to target. This is in line with how the other APIs are named (for example ObjectDataXD have instance type and instance). This would be very hard to change later without breaking backwards compatibility, so I'm doing it now, until the animation APIs get widely used.
8 years ago
if(data->trackTargetType(i) == Trade::AnimationTrackTargetType::Translation3D) {
Trade: document AnimationData usage. This is the last non-obvious thing that needs to be documented in order to make the API usable.
8 years ago
CORRADE_INTERNAL_ASSERT(data->trackType(i) ==
Trade::AnimationTrackType::Vector3);
Trade: change animation track target to target type and target ID to target. This is in line with how the other APIs are named (for example ObjectDataXD have instance type and instance). This would be very hard to change later without breaking backwards compatibility, so I'm doing it now, until the animation APIs get widely used.
8 years ago
player.add(data->track<Vector3>(i), positions[data->trackTarget(i)]);
Trade: document AnimationData usage. This is the last non-obvious thing that needs to be documented in order to make the API usable.
8 years ago
}
// similarly for rotation / scaling ...
}
Containers::Array<char> animationData = data->release(); /* Take ownership */
/* [AnimationData-usage] */
}
Trade: mutable access in AnimationData. Follows the change done in MeshData.
7 years ago
{
Trade::AnimationData data{nullptr, {}};
/* [AnimationData-usage-mutable] */
for(UnsignedInt i = 0; i != data.trackCount(); ++i) {
if(data.trackTargetType(i) != Trade::AnimationTrackTargetType::Translation3D)
continue;
/* Check prerequisites */
if(!(data.dataFlags() & Trade::DataFlag::Mutable) ||
data.trackType(i) != Trade::AnimationTrackType::Vector2)
Fatal{} << "Oops";
MeshTools::transformVectorsInPlace(Matrix4::scaling(Vector3::yScale(-1.0f)),
data.mutableTrack<Vector3>(i).values());
}
/* [AnimationData-usage-mutable] */
}
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
{
/* [ImageData-construction] */
Containers::Array<char> data;
Trade::ImageData2D image{PixelFormat::RGB8Unorm, {32, 32}, std::move(data)};
/* [ImageData-construction] */
}
{
/* [ImageData-construction-compressed] */
Containers::Array<char> data;
Trade::ImageData2D image{CompressedPixelFormat::Bc1RGBUnorm,
{32, 32}, std::move(data)};
/* [ImageData-construction-compressed] */
}
#ifdef MAGNUM_TARGET_GL
{
/* [ImageData-usage] */
Get rid of std::unique_ptr.
7 years ago
Containers::Pointer<Trade::AbstractImporter> importer;
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
Containers::Optional<Trade::ImageData2D> image = importer->image2D(0);
if(!image) Fatal{} << "Oopsie!";
GL::Texture2D texture;
// ...
if(!image->isCompressed())
texture.setSubImage(0, {}, *image);
else
texture.setCompressedSubImage(0, {}, *image);
/* [ImageData-usage] */
}
#endif
Trade: mutable access in ImageData consistent with Animation/MeshData.
7 years ago
{
Trade::ImageData2D data{PixelFormat::RGB8Unorm, {}, nullptr};
/* [ImageData-usage-mutable] */
if(data.isCompressed() ||
data.format() != PixelFormat::RGB8Unorm ||
!(data.dataFlags() & Trade::DataFlag::Mutable))
Fatal{} << ":(";
for(auto&& row: data.mutablePixels<Color3ub>())
for(Color3ub& pixel: row)
pixel = Math::gather<'b', 'g', 'r'>(pixel);
/* [ImageData-usage-mutable] */
}
Trade: high-level docs for the MeshData class.
6 years ago
{
/* [MeshIndexData-usage] */
Containers::ArrayView<const UnsignedShort> indices;
Trade::MeshIndexData data{indices};
/* [MeshIndexData-usage] */
}
Trade: implement support for tangents and bitangents in MeshData. Originally wanted to offload this to someone else, but then realized I need those for generic vertex attribute definitions, which I need for instancing, which I need now. So here it is, at the bottom of the dependency chain.
6 years ago
{
Vector3 normal;
Vector4 tangent;
/* [MeshAttribute-bitangent-from-tangent] */
Vector3 bitangent = Math::cross(normal, tangent.xyz())*tangent.w();
/* [MeshAttribute-bitangent-from-tangent] */
static_cast<void>(bitangent);
}
Trade: high-level docs for the MeshData class.
6 years ago
{
/* [MeshAttributeData-usage] */
Containers::StridedArrayView1D<const Vector3> positions;
Trade::MeshAttributeData data{Trade::MeshAttribute::Position, positions};
/* [MeshAttributeData-usage] */
}
{
/* [MeshAttributeData-usage-offset-only] */
struct Vertex {
Vector3 position;
Vector4 color;
};
/* Layout defined statically, 15 vertices in total */
constexpr Trade::MeshAttributeData positions{Trade::MeshAttribute::Position,
VertexFormat::Vector3, offsetof(Vertex, position), 15, sizeof(Vertex)};
constexpr Trade::MeshAttributeData colors{Trade::MeshAttribute::Color,
VertexFormat::Vector4, offsetof(Vertex, color), 15, sizeof(Vertex)};
/* Actual data populated later */
Containers::Array<char> vertexData{15*sizeof(Vertex)};
// ...
Trade::MeshData{MeshPrimitive::Triangles, std::move(vertexData),
{positions, colors}};
/* [MeshAttributeData-usage-offset-only] */
}
#ifdef MAGNUM_TARGET_VK
{
Containers::StridedArrayView1D<const void> data;
/* [MeshAttributeData-custom-vertex-format] */
Trade::MeshAttributeData normals{Trade::MeshAttribute::Normal,
vertexFormatWrap(VK_FORMAT_B10G11R11_UFLOAT_PACK32),
data};
/* [MeshAttributeData-custom-vertex-format] */
}
#endif
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
#ifdef MAGNUM_TARGET_GL
{
Trade::MeshData data{MeshPrimitive::Points, 0};
/* [MeshData-usage] */
/* Check that we have at least positions and normals */
GL::Mesh mesh{data.primitive()};
if(!data.hasAttribute(Trade::MeshAttribute::Position) ||
!data.hasAttribute(Trade::MeshAttribute::Normal))
Fatal{} << "Oh well";
/* Interleave vertex data */
GL::Buffer vertices;
vertices.setData(MeshTools::interleave(data.positions3DAsArray(),
data.normalsAsArray()));
mesh.addVertexBuffer(std::move(vertices), 0,
Shaders::Phong::Position{}, Shaders::Phong::Normal{});
/* Set up an index buffer, if the mesh is indexed*/
if(data.isIndexed()) {
GL::Buffer indices;
indices.setData(data.indicesAsArray());
mesh.setIndexBuffer(std::move(indices), 0, MeshIndexType::UnsignedInt)
.setCount(data.indexCount());
} else mesh.setCount(data.vertexCount());
/* [MeshData-usage] */
}
{
Trade::MeshData data{MeshPrimitive::Points, 0};
GL::Mesh mesh{data.primitive()};
/* [MeshData-usage-advanced] */
/* Upload the original packed vertex data */
GL::Buffer vertices;
vertices.setData(data.vertexData());
GL: allow to construct DynamicAttribute from VertexFormat.
6 years ago
/* Set up the position and normal attributes */
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
mesh.addVertexBuffer(vertices,
data.attributeOffset(Trade::MeshAttribute::Position),
GL: allow to construct DynamicAttribute from VertexFormat.
6 years ago
data.attributeStride(Trade::MeshAttribute::Position),
GL::DynamicAttribute{Shaders::Phong::Position{},
data.attributeFormat(Trade::MeshAttribute::Position)});
mesh.addVertexBuffer(vertices,
data.attributeOffset(Trade::MeshAttribute::Normal),
data.attributeStride(Trade::MeshAttribute::Normal),
GL::DynamicAttribute{Shaders::Phong::Normal{},
data.attributeFormat(Trade::MeshAttribute::Normal)});
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
// Set up other attributes ...
/* Upload the original packed index data */
if(data.isIndexed()) {
GL::Buffer indices;
indices.setData(data.indexData());
mesh.setIndexBuffer(std::move(indices), 0, data.indexType())
.setCount(data.indexCount());
} else mesh.setCount(data.vertexCount());
/* [MeshData-usage-advanced] */
}
Trade: high-level docs for the MeshData class.
6 years ago
{
Trade::MeshData data{MeshPrimitive::Points, 0};
/* [MeshData-usage-compile] */
GL::Mesh mesh = MeshTools::compile(data);
/* [MeshData-usage-compile] */
}
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
#endif
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
{
Trade::MeshData data{MeshPrimitive::Points, 0};
/* [MeshData-usage-mutable] */
/* Check prerequisites */
if(!(data.vertexDataFlags() & Trade::DataFlag::Mutable) ||
!data.hasAttribute(Trade::MeshAttribute::Position) ||
data.attributeFormat(Trade::MeshAttribute::Position) != VertexFormat::Vector3)
Fatal{} << "Oh well";
/* Scale the mesh two times */
MeshTools::transformPointsInPlace(Matrix4::scaling(Vector3{2.0f}),
data.mutableAttribute<Vector3>(Trade::MeshAttribute::Position));
/* [MeshData-usage-mutable] */
}
Trade: high-level docs for the MeshData class.
6 years ago
{
std::size_t vertexCount{}, indexCount{};
/* [MeshData-populating] */
struct Vertex {
Vector3 position;
Vector4 color;
};
Containers::Array<char> indexData{indexCount*sizeof(UnsignedShort)};
Containers::Array<char> vertexData{vertexCount*sizeof(Vertex)};
// …
auto vertices = Containers::arrayCast<const Vertex>(vertexData);
auto indices = Containers::arrayCast<const UnsignedShort>(indexData);
Trade::MeshData data{MeshPrimitive::Triangles,
std::move(indexData), Trade::MeshIndexData{indices},
std::move(vertexData), {
Trade::MeshAttributeData{Trade::MeshAttribute::Position,
Containers::StridedArrayView1D<const Vector3>{vertices,
&vertices[0].position, vertexCount, sizeof(Vertex)}},
Trade::MeshAttributeData{Trade::MeshAttribute::Color,
Containers::StridedArrayView1D<const Vector4>{vertices,
&vertices[0].color, vertexCount, sizeof(Vertex)}}
}};
/* [MeshData-populating] */
}
{
struct Vertex {
Vector3 position;
Vector4 color;
};
/* [MeshData-populating-non-owned] */
const UnsignedShort indices[] {
0, 1, 2,
2, 1, 3,
3, 4, 5,
5, 4, 6
};
Vertex vertices[7];
Trade::MeshData data{MeshPrimitive::Triangles,
Trade::DataFlags{}, indices, Trade::MeshIndexData{indices},
Trade::DataFlag::Mutable, vertices, {
Trade::MeshAttributeData{Trade::MeshAttribute::Position,
Containers::StridedArrayView1D<const Vector3>{
Containers::arrayView(vertices), &vertices[0].position,
Containers::arraySize(vertices), sizeof(Vertex)}},
Trade::MeshAttributeData{Trade::MeshAttribute::Color,
Containers::StridedArrayView1D<const Vector4>{
Containers::arrayView(vertices), &vertices[0].color,
Containers::arraySize(vertices), sizeof(Vertex)}}
}};
/* [MeshData-populating-non-owned] */
}
{
/* [MeshData-populating-custom] */
/* Each face can consist of 15 triangles at most, triangleCount says how many
indices in triangleIds are valid */
struct Face {
UnsignedShort triangleIds[15];
UnsignedByte triangleCount;
};
constexpr Trade::MeshAttribute TriangleIds = Trade::meshAttributeCustom(0x01);
constexpr Trade::MeshAttribute TriangleCount = Trade::meshAttributeCustom(0x02);
Containers::Array<char> vertexData;
auto faces = Containers::arrayCast<const Face>(vertexData);
Trade::MeshData data{MeshPrimitive::Faces, std::move(vertexData), {
Trade::MeshAttributeData{TriangleIds,
Containers::StridedArrayView2D<const UnsignedShort>{faces,
&faces[0].triangleIds[0],
{faces.size(), 15},
{sizeof(Face), sizeof(UnsignedShort)}}},
Trade::MeshAttributeData{TriangleCount,
Containers::StridedArrayView1D<const UnsignedByte>{faces,
&faces[0].triangleCount, faces.size(), sizeof(Face)}}
}};
/* [MeshData-populating-custom] */
/* [MeshData-populating-custom-retrieve] */
Containers::StridedArrayView2D<const UnsignedShort> triangleIds =
data.attribute<UnsignedShort[]>(TriangleIds);
Containers::StridedArrayView1D<const UnsignedByte> triangleCounts =
data.attribute<UnsignedByte>(TriangleCount);
/* [MeshData-populating-custom-retrieve] */
static_cast<void>(triangleIds);
static_cast<void>(triangleCounts);
}
Trade, MeshTools: deprecate MeshDataXD and everything that uses it.
6 years ago
#ifdef MAGNUM_BUILD_DEPRECATED
Trade: support separate translation/rotation/scaling in ObjectData. Doesn't make any backwards-incompatible change -- plugins can still export the transformation as matrix and users can still access the combined one even if separate transformations are used. Yay!
8 years ago
{
Trade, MeshTools: deprecate MeshDataXD and everything that uses it.
6 years ago
CORRADE_IGNORE_DEPRECATED_PUSH
Trade: document how MeshData can be further transformed.
8 years ago
Trade::MeshData2D& foo();
Trade::MeshData2D& data = foo();
/* [MeshData2D-transform] */
Matrix3 transformation =
Matrix3::translation({3.0f, -2.0f})*
Matrix3::scaling(Vector2{2.0f})*
Matrix3::rotation(45.0_degf);
MeshTools::transformPointsInPlace(transformation, data.positions(0));
/* [MeshData2D-transform] */
Trade, MeshTools: deprecate MeshDataXD and everything that uses it.
6 years ago
CORRADE_IGNORE_DEPRECATED_POP
Trade: document how MeshData can be further transformed.
8 years ago
}
Trade, MeshTools: deprecate MeshDataXD and everything that uses it.
6 years ago
#endif
Trade: document how MeshData can be further transformed.
8 years ago
{
Trade::ObjectData2D& baz();
Trade::ObjectData2D& data = baz();
Trade: support separate translation/rotation/scaling in ObjectData. Doesn't make any backwards-incompatible change -- plugins can still export the transformation as matrix and users can still access the combined one even if separate transformations are used. Yay!
8 years ago
/* [ObjectData2D-transformation] */
Matrix3 transformation =
Matrix3::from(data.rotation().toMatrix(), data.translation())*
Matrix3::scaling(data.scaling());
/* [ObjectData2D-transformation] */
static_cast<void>(transformation);
}
Trade, MeshTools: deprecate MeshDataXD and everything that uses it.
6 years ago
#ifdef MAGNUM_BUILD_DEPRECATED
Trade: support separate translation/rotation/scaling in ObjectData. Doesn't make any backwards-incompatible change -- plugins can still export the transformation as matrix and users can still access the combined one even if separate transformations are used. Yay!
8 years ago
{
Trade, MeshTools: deprecate MeshDataXD and everything that uses it.
6 years ago
CORRADE_IGNORE_DEPRECATED_PUSH
Trade: document how MeshData can be further transformed.
8 years ago
Trade::MeshData3D& bar();
Trade::MeshData3D& data = bar();
/* [MeshData3D-transform] */
Matrix4 transformation =
Matrix4::translation({3.0f, 1.5f, -2.0f})*
Matrix4::rotationX(45.0_degf);
MeshTools::transformPointsInPlace(transformation, data.positions(0));
MeshTools::transformVectorsInPlace(transformation, data.normals(0));
/* [MeshData3D-transform] */
Trade, MeshTools: deprecate MeshDataXD and everything that uses it.
6 years ago
CORRADE_IGNORE_DEPRECATED_POP
Trade: document how MeshData can be further transformed.
8 years ago
}
Trade, MeshTools: deprecate MeshDataXD and everything that uses it.
6 years ago
#endif
Trade: document how MeshData can be further transformed.
8 years ago
{
Trade::ObjectData3D& fizz();
Trade::ObjectData3D& data = fizz();
Trade: support separate translation/rotation/scaling in ObjectData. Doesn't make any backwards-incompatible change -- plugins can still export the transformation as matrix and users can still access the combined one even if separate transformations are used. Yay!
8 years ago
/* [ObjectData3D-transformation] */
Matrix4 transformation =
Matrix4::from(data.rotation().toMatrix(), data.translation())*
Matrix4::scaling(data.scaling());
/* [ObjectData3D-transformation] */
static_cast<void>(transformation);
}
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
}