From c0d21e21466350aaeb41f67196252061b58f3ce0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= Date: Sun, 29 Nov 2015 19:25:20 +0100 Subject: [PATCH] Trade: provide a way to access importer-specific data from all classes. --- src/Magnum/Trade/AbstractImporter.cpp | 7 +++++ src/Magnum/Trade/AbstractImporter.h | 18 +++++++++++++ src/Magnum/Trade/AbstractMaterialData.cpp | 2 +- src/Magnum/Trade/AbstractMaterialData.h | 13 +++++++-- src/Magnum/Trade/CameraData.h | 22 +++++++++++----- src/Magnum/Trade/ImageData.cpp | 2 +- src/Magnum/Trade/ImageData.h | 32 ++++++++++++++++------- src/Magnum/Trade/MeshData2D.cpp | 2 +- src/Magnum/Trade/MeshData2D.h | 11 +++++++- src/Magnum/Trade/MeshData3D.cpp | 2 +- src/Magnum/Trade/MeshData3D.h | 11 +++++++- src/Magnum/Trade/MeshObjectData2D.cpp | 2 +- src/Magnum/Trade/MeshObjectData2D.h | 3 ++- src/Magnum/Trade/MeshObjectData3D.cpp | 2 +- src/Magnum/Trade/MeshObjectData3D.h | 3 ++- src/Magnum/Trade/ObjectData2D.cpp | 4 +-- src/Magnum/Trade/ObjectData2D.h | 14 ++++++++-- src/Magnum/Trade/ObjectData3D.cpp | 4 +-- src/Magnum/Trade/ObjectData3D.h | 14 ++++++++-- src/Magnum/Trade/PhongMaterialData.h | 7 ++--- src/Magnum/Trade/SceneData.cpp | 2 +- src/Magnum/Trade/SceneData.h | 15 ++++++++--- src/Magnum/Trade/TextureData.h | 11 +++++++- 23 files changed, 159 insertions(+), 44 deletions(-) diff --git a/src/Magnum/Trade/AbstractImporter.cpp b/src/Magnum/Trade/AbstractImporter.cpp index 7d6733ba2..808748006 100644 --- a/src/Magnum/Trade/AbstractImporter.cpp +++ b/src/Magnum/Trade/AbstractImporter.cpp @@ -454,4 +454,11 @@ std::optional AbstractImporter::image3D(const UnsignedInt id) { std::optional AbstractImporter::doImage3D(UnsignedInt) { return std::nullopt; } +const void* AbstractImporter::importerState() const { + CORRADE_ASSERT(isOpened(), "Trade::AbstractImporter::importerState(): no file opened", {}); + return doImporterState(); +} + +const void* AbstractImporter::doImporterState() const { return nullptr; } + }} diff --git a/src/Magnum/Trade/AbstractImporter.h b/src/Magnum/Trade/AbstractImporter.h index ad1893ac1..8011a799b 100644 --- a/src/Magnum/Trade/AbstractImporter.h +++ b/src/Magnum/Trade/AbstractImporter.h @@ -471,6 +471,21 @@ class MAGNUM_EXPORT AbstractImporter: public PluginManager::AbstractManagingPlug /*@}*/ + /** + * @brief Plugin-specific access to internal importer state + * + * The importer might provide access to its internal data structures + * for currently opened document through this function. See + * documentation of particular plugin for more information about + * returned type and contents. Returns `nullptr` by default. + * @see @ref AbstractMaterialData::importerState(), + * @ref CameraData::importerState(), @ref ImageData::importerState(), + * @ref MeshData2D::importerState(), @ref MeshData3D::importerState(), + * @ref ObjectData2D::importerState(), @ref ObjectData3D::importerState(), + * @ref SceneData::importerState(), @ref TextureData::importerState() + */ + const void* importerState() const; + protected: /** * @brief Implementation for @ref openFile() @@ -793,6 +808,9 @@ class MAGNUM_EXPORT AbstractImporter: public PluginManager::AbstractManagingPlug /** @brief Implementation for @ref image3D() */ virtual std::optional doImage3D(UnsignedInt id); + + /** @brief Implementation for @ref importerState() */ + virtual const void* doImporterState() const; }; CORRADE_ENUMSET_OPERATORS(AbstractImporter::Features) diff --git a/src/Magnum/Trade/AbstractMaterialData.cpp b/src/Magnum/Trade/AbstractMaterialData.cpp index e4f7475b8..ba2cf200e 100644 --- a/src/Magnum/Trade/AbstractMaterialData.cpp +++ b/src/Magnum/Trade/AbstractMaterialData.cpp @@ -29,7 +29,7 @@ namespace Magnum { namespace Trade { -AbstractMaterialData::AbstractMaterialData(MaterialType type): _type(type) {} +AbstractMaterialData::AbstractMaterialData(const MaterialType type, const void* const importerState): _type{type}, _importerState{importerState} {} AbstractMaterialData::~AbstractMaterialData() {} diff --git a/src/Magnum/Trade/AbstractMaterialData.h b/src/Magnum/Trade/AbstractMaterialData.h index 474e40b7f..0ac57ab4d 100644 --- a/src/Magnum/Trade/AbstractMaterialData.h +++ b/src/Magnum/Trade/AbstractMaterialData.h @@ -52,9 +52,10 @@ class MAGNUM_EXPORT AbstractMaterialData { public: /** * @brief Constructor - * @param type Material type + * @param type Material type + * @param importerState Importer-specific state */ - explicit AbstractMaterialData(MaterialType type); + explicit AbstractMaterialData(MaterialType type, const void* importerState = nullptr); /** @brief Destructor */ virtual ~AbstractMaterialData() = 0; @@ -74,8 +75,16 @@ class MAGNUM_EXPORT AbstractMaterialData { /** @brief Material type */ MaterialType type() const { return _type; } + /** + * @brief Importer-specific state + * + * See @ref AbstractImporter::importerState() for more information. + */ + const void* importerState() const { return _importerState; } + private: MaterialType _type; + const void* _importerState; }; /** @debugoperatorenum{Magnum::Trade::MaterialType} */ diff --git a/src/Magnum/Trade/CameraData.h b/src/Magnum/Trade/CameraData.h index 6a6c18443..045fc36da 100644 --- a/src/Magnum/Trade/CameraData.h +++ b/src/Magnum/Trade/CameraData.h @@ -43,15 +43,16 @@ class CameraData { public: /** * @brief Constructor - * @param fov Field-of-view angle - * @param near Near clipping plane - * @param far Far clipping plane + * @param fov Field-of-view angle + * @param near Near clipping plane + * @param far Far clipping plane + * @param importerState Importer-specific state * * If `NaN` is specified for any parameter, default value is used * instead, which is `35.0_degf` for @p fov, `0.01f` for @p near and * `100.0f` for @p far. */ - explicit CameraData(Rad fov, Float near, Float far) noexcept; + explicit CameraData(Rad fov, Float near, Float far, const void* importerState = nullptr) noexcept; /** @brief Field-of-view angle */ Rad fov() const { return _fov; } @@ -62,15 +63,24 @@ class CameraData { /** @brief Far clipping plane */ Float far() const { return _far; } + /** + * @brief Importer-specific state + * + * See @ref AbstractImporter::importerState() for more information. + */ + const void* importerState() const { return _importerState; } + private: Rad _fov; Float _near, _far; + const void* _importerState; }; -inline CameraData::CameraData(Rad fov, Float near, Float far) noexcept: +inline CameraData::CameraData(const Rad fov, const Float near, const Float far, const void* const importerState) noexcept: _fov{fov != fov ? Rad{35.0_degf} : fov}, _near{near != near ? 0.01f : near}, - _far{far != far ? 100.0f : far} {} + _far{far != far ? 100.0f : far}, + _importerState{importerState} {} }} diff --git a/src/Magnum/Trade/ImageData.cpp b/src/Magnum/Trade/ImageData.cpp index 179ae5b52..16303a39a 100644 --- a/src/Magnum/Trade/ImageData.cpp +++ b/src/Magnum/Trade/ImageData.cpp @@ -27,7 +27,7 @@ namespace Magnum { namespace Trade { -template ImageData::ImageData(const PixelStorage storage, const PixelFormat format, const PixelType type, const VectorTypeFor& size, Containers::Array&& data): _compressed{false}, _storage{storage}, _format{format}, _type{type}, _size{size}, _data{std::move(data)} { +template ImageData::ImageData(const PixelStorage storage, const PixelFormat format, const PixelType type, const VectorTypeFor& size, Containers::Array&& data, const void* const importerState): _compressed{false}, _storage{storage}, _format{format}, _type{type}, _size{size}, _data{std::move(data)}, _importerState{importerState} { CORRADE_ASSERT(Implementation::imageDataSize(*this) <= _data.size(), "Trade::ImageData::ImageData(): bad image data size, got" << _data.size() << "but expected at least" << Implementation::imageDataSize(*this), ); } diff --git a/src/Magnum/Trade/ImageData.h b/src/Magnum/Trade/ImageData.h index 77aaf941b..1071fed2a 100644 --- a/src/Magnum/Trade/ImageData.h +++ b/src/Magnum/Trade/ImageData.h @@ -63,20 +63,21 @@ template class ImageData { * @param type Data type of pixel data * @param size Image size * @param data Image data + * @param importerState Importer-specific state * * The data are expected to be of proper size for given @p storage * parameters. */ - explicit ImageData(PixelStorage storage, PixelFormat format, PixelType type, const VectorTypeFor& size, Containers::Array&& data); + explicit ImageData(PixelStorage storage, PixelFormat format, PixelType type, const VectorTypeFor& size, Containers::Array&& data, const void* importerState = nullptr); /** @overload * Similar to the above, but uses default @ref PixelStorage parameters. */ - explicit ImageData(PixelFormat format, PixelType type, const VectorTypeFor& size, Containers::Array&& data): ImageData{{}, format, type, size, std::move(data)} {} + explicit ImageData(PixelFormat format, PixelType type, const VectorTypeFor& size, Containers::Array&& data, const void* importerState = nullptr): ImageData{{}, format, type, size, std::move(data), importerState} {} #ifdef MAGNUM_BUILD_DEPRECATED - /** @copybrief ImageData(PixelFormat, PixelType, const VectorTypeFor&, Containers::Array&&) - * @deprecated Use @ref ImageData(PixelFormat, PixelType, const VectorTypeFor&, Containers::Array&&) instead. + /** @copybrief ImageData(PixelFormat, PixelType, const VectorTypeFor&, Containers::Array&&, const void*) + * @deprecated Use @ref ImageData(PixelFormat, PixelType, const VectorTypeFor&, Containers::Array&&, const void*) instead. */ explicit CORRADE_DEPRECATED("use ImageData(PixelFormat, PixelType, const VectorTypeFor&, Containers::Array&&) instead") ImageData(PixelFormat format, PixelType type, const VectorTypeFor& size, void* data): ImageData{format, type, size, Containers::Array{reinterpret_cast(data), Magnum::Implementation::imageDataSizeFor(format, type, size)}} {} #endif @@ -88,6 +89,7 @@ template class ImageData { * @param format Format of compressed pixel data * @param size Image size * @param data Image data + * @param importerState Importer-specific state * * Note that the image data are not copied on construction, but they * are deleted on class destruction. @@ -95,7 +97,7 @@ template class ImageData { * @requires_gl Compressed pixel storage is hardcoded in OpenGL ES and * WebGL. */ - explicit ImageData(CompressedPixelStorage storage, CompressedPixelFormat format, const VectorTypeFor& size, Containers::Array&& data); + explicit ImageData(CompressedPixelStorage storage, CompressedPixelFormat format, const VectorTypeFor& size, Containers::Array&& data, const void* importerState = nullptr); #endif /** @@ -103,11 +105,12 @@ template class ImageData { * @param format Format of compressed pixel data * @param size Image size * @param data Image data + * @param importerState Importer-specific state * * Similar the above, but uses default @ref CompressedPixelStorage * parameters (or the hardcoded ones in OpenGL ES and WebGL). */ - explicit ImageData(CompressedPixelFormat format, const VectorTypeFor& size, Containers::Array&& data); + explicit ImageData(CompressedPixelFormat format, const VectorTypeFor& size, Containers::Array&& data, const void* importerState = nullptr); /** @brief Copying is not allowed */ ImageData(const ImageData&) = delete; @@ -242,6 +245,13 @@ template class ImageData { */ Containers::Array release(); + /** + * @brief Importer-specific state + * + * See @ref AbstractImporter::importerState() for more information. + */ + const void* importerState() const { return _importerState; } + private: bool _compressed; union { @@ -257,6 +267,7 @@ template class ImageData { PixelType _type; Math::Vector _size; Containers::Array _data; + const void* _importerState; }; /** @brief One-dimensional image */ @@ -272,17 +283,17 @@ template ImageData::ImageData( #ifndef MAGNUM_TARGET_GLES const CompressedPixelStorage storage, #endif - const CompressedPixelFormat format, const VectorTypeFor& size, Containers::Array&& data): _compressed{true}, + const CompressedPixelFormat format, const VectorTypeFor& size, Containers::Array&& data, const void* importerState): _compressed{true}, #ifndef MAGNUM_TARGET_GLES _compressedStorage{storage}, #endif - _compressedFormat{format}, _size{size}, _data{std::move(data)} {} + _compressedFormat{format}, _size{size}, _data{std::move(data)}, _importerState{importerState} {} #ifndef MAGNUM_TARGET_GLES -template inline ImageData::ImageData(const CompressedPixelFormat format, const VectorTypeFor& size, Containers::Array&& data): ImageData{{}, format, size, std::move(data)} {} +template inline ImageData::ImageData(const CompressedPixelFormat format, const VectorTypeFor& size, Containers::Array&& data, const void* const importerState): ImageData{{}, format, size, std::move(data), importerState} {} #endif -template inline ImageData::ImageData(ImageData&& other) noexcept: _compressed{std::move(other._compressed)}, _size{std::move(other._size)}, _data{std::move(other._data)} { +template inline ImageData::ImageData(ImageData&& other) noexcept: _compressed{std::move(other._compressed)}, _size{std::move(other._size)}, _data{std::move(other._data)}, _importerState{std::move(other._importerState)} { if(_compressed) { #ifndef MAGNUM_TARGET_GLES new(&_compressedStorage) CompressedPixelStorage{std::move(other._compressedStorage)}; @@ -314,6 +325,7 @@ template inline ImageData& ImageData indices, std::vector> positions, std::vector> textureCoords2D): _primitive(primitive), _indices(std::move(indices)), _positions(std::move(positions)), _textureCoords2D(std::move(textureCoords2D)) { +MeshData2D::MeshData2D(const MeshPrimitive primitive, std::vector indices, std::vector> positions, std::vector> textureCoords2D, const void* const importerState): _primitive{primitive}, _indices{std::move(indices)}, _positions{std::move(positions)}, _textureCoords2D{std::move(textureCoords2D)}, _importerState{importerState} { CORRADE_ASSERT(!_positions.empty(), "Trade::MeshData2D: no position array specified", ); } diff --git a/src/Magnum/Trade/MeshData2D.h b/src/Magnum/Trade/MeshData2D.h index d7759ea6c..a58f5685f 100644 --- a/src/Magnum/Trade/MeshData2D.h +++ b/src/Magnum/Trade/MeshData2D.h @@ -54,8 +54,9 @@ class MAGNUM_EXPORT MeshData2D { * array should be present. * @param textureCoords2D Two-dimensional texture coordinate arrays, * if present + * @param importerState Importer-specific state */ - explicit MeshData2D(MeshPrimitive primitive, std::vector indices, std::vector> positions, std::vector> textureCoords2D); + explicit MeshData2D(MeshPrimitive primitive, std::vector indices, std::vector> positions, std::vector> textureCoords2D, const void* importerState = nullptr); /** @brief Copying is not allowed */ MeshData2D(const MeshData2D&) = delete; @@ -116,11 +117,19 @@ class MAGNUM_EXPORT MeshData2D { std::vector& textureCoords2D(UnsignedInt id); const std::vector& textureCoords2D(UnsignedInt id) const; /**< @overload */ + /** + * @brief Importer-specific state + * + * See @ref AbstractImporter::importerState() for more information. + */ + const void* importerState() const { return _importerState; } + private: MeshPrimitive _primitive; std::vector _indices; std::vector> _positions; std::vector> _textureCoords2D; + const void* _importerState; }; }} diff --git a/src/Magnum/Trade/MeshData3D.cpp b/src/Magnum/Trade/MeshData3D.cpp index 4362922d4..76b3f04dd 100644 --- a/src/Magnum/Trade/MeshData3D.cpp +++ b/src/Magnum/Trade/MeshData3D.cpp @@ -29,7 +29,7 @@ namespace Magnum { namespace Trade { -MeshData3D::MeshData3D(MeshPrimitive primitive, std::vector indices, std::vector> positions, std::vector> normals, std::vector> textureCoords2D): _primitive(primitive), _indices(std::move(indices)), _positions(std::move(positions)), _normals(std::move(normals)), _textureCoords2D(std::move(textureCoords2D)) { +MeshData3D::MeshData3D(const MeshPrimitive primitive, std::vector indices, std::vector> positions, std::vector> normals, std::vector> textureCoords2D, const void* const importerState): _primitive{primitive}, _indices{std::move(indices)}, _positions{std::move(positions)}, _normals{std::move(normals)}, _textureCoords2D{std::move(textureCoords2D)}, _importerState{importerState} { CORRADE_ASSERT(!_positions.empty(), "Trade::MeshData3D: no position array specified", ); } diff --git a/src/Magnum/Trade/MeshData3D.h b/src/Magnum/Trade/MeshData3D.h index b54acae18..64a5ca02d 100644 --- a/src/Magnum/Trade/MeshData3D.h +++ b/src/Magnum/Trade/MeshData3D.h @@ -55,8 +55,9 @@ class MAGNUM_EXPORT MeshData3D { * @param normals Normal arrays, if present * @param textureCoords2D Two-dimensional texture coordinate arrays, * if present + * @param importerState Importer-specific state */ - explicit MeshData3D(MeshPrimitive primitive, std::vector indices, std::vector> positions, std::vector> normals, std::vector> textureCoords2D); + explicit MeshData3D(MeshPrimitive primitive, std::vector indices, std::vector> positions, std::vector> normals, std::vector> textureCoords2D, const void* importerState = nullptr); /** @brief Copying is not allowed */ MeshData3D(const MeshData3D&) = delete; @@ -132,12 +133,20 @@ class MAGNUM_EXPORT MeshData3D { std::vector& textureCoords2D(UnsignedInt id); const std::vector& textureCoords2D(UnsignedInt id) const; /**< @overload */ + /** + * @brief Importer-specific state + * + * See @ref AbstractImporter::importerState() for more information. + */ + const void* importerState() const { return _importerState; } + private: MeshPrimitive _primitive; std::vector _indices; std::vector> _positions; std::vector> _normals; std::vector> _textureCoords2D; + const void* _importerState; }; }} diff --git a/src/Magnum/Trade/MeshObjectData2D.cpp b/src/Magnum/Trade/MeshObjectData2D.cpp index 0026d6f11..c3e94271f 100644 --- a/src/Magnum/Trade/MeshObjectData2D.cpp +++ b/src/Magnum/Trade/MeshObjectData2D.cpp @@ -27,6 +27,6 @@ namespace Magnum { namespace Trade { -MeshObjectData2D::MeshObjectData2D(std::vector children, const Matrix3& transformation, UnsignedInt instance, Int material): ObjectData2D(std::move(children), transformation, ObjectInstanceType2D::Mesh, instance), _material(material) {} +MeshObjectData2D::MeshObjectData2D(std::vector children, const Matrix3& transformation, const UnsignedInt instance, const Int material, const void* const importerState): ObjectData2D{std::move(children), transformation, ObjectInstanceType2D::Mesh, instance, importerState}, _material{material} {} }} diff --git a/src/Magnum/Trade/MeshObjectData2D.h b/src/Magnum/Trade/MeshObjectData2D.h index 3fc28ab1c..39c349593 100644 --- a/src/Magnum/Trade/MeshObjectData2D.h +++ b/src/Magnum/Trade/MeshObjectData2D.h @@ -47,10 +47,11 @@ class MAGNUM_EXPORT MeshObjectData2D: public ObjectData2D { * @param transformation Transformation (relative to parent) * @param instance Instance ID * @param material Material ID or `-1` + * @param importerState Importer-specific state * * Creates object with mesh instance type. */ - explicit MeshObjectData2D(std::vector children, const Matrix3& transformation, UnsignedInt instance, Int material); + explicit MeshObjectData2D(std::vector children, const Matrix3& transformation, UnsignedInt instance, Int material, const void* importerState = nullptr); /** @brief Copying is not allowed */ MeshObjectData2D(const MeshObjectData2D&) = delete; diff --git a/src/Magnum/Trade/MeshObjectData3D.cpp b/src/Magnum/Trade/MeshObjectData3D.cpp index 4580d4837..76f51d2bc 100644 --- a/src/Magnum/Trade/MeshObjectData3D.cpp +++ b/src/Magnum/Trade/MeshObjectData3D.cpp @@ -27,6 +27,6 @@ namespace Magnum { namespace Trade { -MeshObjectData3D::MeshObjectData3D(std::vector children, const Matrix4& transformation, UnsignedInt instance, Int material): ObjectData3D(std::move(children), transformation, ObjectInstanceType3D::Mesh, instance), _material(material) {} +MeshObjectData3D::MeshObjectData3D(std::vector children, const Matrix4& transformation, const UnsignedInt instance, const Int material, const void* const importerState): ObjectData3D{std::move(children), transformation, ObjectInstanceType3D::Mesh, instance, importerState}, _material{material} {} }} diff --git a/src/Magnum/Trade/MeshObjectData3D.h b/src/Magnum/Trade/MeshObjectData3D.h index c25e0cdf6..d536e208b 100644 --- a/src/Magnum/Trade/MeshObjectData3D.h +++ b/src/Magnum/Trade/MeshObjectData3D.h @@ -47,10 +47,11 @@ class MAGNUM_EXPORT MeshObjectData3D: public ObjectData3D { * @param transformation Transformation (relative to parent) * @param instance Instance ID * @param material Material ID or `-1` + * @param importerState Importer-specific state * * Creates object with mesh instance type. */ - explicit MeshObjectData3D(std::vector children, const Matrix4& transformation, UnsignedInt instance, Int material); + explicit MeshObjectData3D(std::vector children, const Matrix4& transformation, UnsignedInt instance, Int material, const void* importerState = nullptr); /** @brief Copying is not allowed */ MeshObjectData3D(const MeshObjectData3D&) = delete; diff --git a/src/Magnum/Trade/ObjectData2D.cpp b/src/Magnum/Trade/ObjectData2D.cpp index 28152878e..a11327c66 100644 --- a/src/Magnum/Trade/ObjectData2D.cpp +++ b/src/Magnum/Trade/ObjectData2D.cpp @@ -27,9 +27,9 @@ namespace Magnum { namespace Trade { -ObjectData2D::ObjectData2D(std::vector children, const Matrix3& transformation, ObjectInstanceType2D instanceType, UnsignedInt instance): _children(std::move(children)), _transformation(transformation), _instanceType(instanceType), _instance(instance) {} +ObjectData2D::ObjectData2D(std::vector children, const Matrix3& transformation, const ObjectInstanceType2D instanceType, const UnsignedInt instance, const void* const importerState): _children{std::move(children)}, _transformation{transformation}, _instanceType{instanceType}, _instance{Int(instance)}, _importerState{importerState} {} -ObjectData2D::ObjectData2D(std::vector children, const Matrix3& transformation): _children(std::move(children)), _transformation(transformation), _instanceType(ObjectInstanceType2D::Empty), _instance(-1) {} +ObjectData2D::ObjectData2D(std::vector children, const Matrix3& transformation, const void* const importerState): _children{std::move(children)}, _transformation{transformation}, _instanceType{ObjectInstanceType2D::Empty}, _instance{-1}, _importerState{importerState} {} ObjectData2D::ObjectData2D(ObjectData2D&&) = default; diff --git a/src/Magnum/Trade/ObjectData2D.h b/src/Magnum/Trade/ObjectData2D.h index cd56be741..d2b952e0d 100644 --- a/src/Magnum/Trade/ObjectData2D.h +++ b/src/Magnum/Trade/ObjectData2D.h @@ -67,15 +67,17 @@ class MAGNUM_EXPORT ObjectData2D { * @param transformation Transformation (relative to parent) * @param instanceType Instance type * @param instance Instance ID + * @param importerState Importer-specific state */ - explicit ObjectData2D(std::vector children, const Matrix3& transformation, ObjectInstanceType2D instanceType, UnsignedInt instance); + explicit ObjectData2D(std::vector children, const Matrix3& transformation, ObjectInstanceType2D instanceType, UnsignedInt instance, const void* importerState = nullptr); /** * @brief Constructor for empty instance * @param children Child objects * @param transformation Transformation (relative to parent) + * @param importerState Importer-specific state */ - explicit ObjectData2D(std::vector children, const Matrix3& transformation); + explicit ObjectData2D(std::vector children, const Matrix3& transformation, const void* importerState = nullptr); /** @brief Copying is not allowed */ ObjectData2D(const ObjectData2D&) = delete; @@ -113,11 +115,19 @@ class MAGNUM_EXPORT ObjectData2D { */ Int instance() const { return _instance; } + /** + * @brief Importer-specific state + * + * See @ref AbstractImporter::importerState() for more information. + */ + const void* importerState() const { return _importerState; } + private: std::vector _children; Matrix3 _transformation; ObjectInstanceType2D _instanceType; Int _instance; + const void* _importerState; }; /** @debugoperatorenum{Magnum::Trade::ObjectInstanceType2D} */ diff --git a/src/Magnum/Trade/ObjectData3D.cpp b/src/Magnum/Trade/ObjectData3D.cpp index 2f1737193..3afcb99fa 100644 --- a/src/Magnum/Trade/ObjectData3D.cpp +++ b/src/Magnum/Trade/ObjectData3D.cpp @@ -27,9 +27,9 @@ namespace Magnum { namespace Trade { -ObjectData3D::ObjectData3D(std::vector children, const Matrix4& transformation, ObjectInstanceType3D instanceType, UnsignedInt instance): _children(std::move(children)), _transformation(transformation), _instanceType(instanceType), _instance(instance) {} +ObjectData3D::ObjectData3D(std::vector children, const Matrix4& transformation, const ObjectInstanceType3D instanceType, const UnsignedInt instance, const void* const importerState): _children{std::move(children)}, _transformation{transformation}, _instanceType{instanceType}, _instance{Int(instance)}, _importerState{importerState} {} -ObjectData3D::ObjectData3D(std::vector children, const Matrix4& transformation): _children(std::move(children)), _transformation(transformation), _instanceType(ObjectInstanceType3D::Empty), _instance(-1) {} +ObjectData3D::ObjectData3D(std::vector children, const Matrix4& transformation, const void* const importerState): _children{std::move(children)}, _transformation{transformation}, _instanceType{ObjectInstanceType3D::Empty}, _instance{-1}, _importerState{importerState} {} ObjectData3D::ObjectData3D(ObjectData3D&&) = default; diff --git a/src/Magnum/Trade/ObjectData3D.h b/src/Magnum/Trade/ObjectData3D.h index 679611152..05f71dbf2 100644 --- a/src/Magnum/Trade/ObjectData3D.h +++ b/src/Magnum/Trade/ObjectData3D.h @@ -69,15 +69,17 @@ class MAGNUM_EXPORT ObjectData3D { * @param transformation Transformation (relative to parent) * @param instanceType Instance type * @param instance Instance ID + * @param importerState Importer-specific state */ - explicit ObjectData3D(std::vector children, const Matrix4& transformation, ObjectInstanceType3D instanceType, UnsignedInt instance); + explicit ObjectData3D(std::vector children, const Matrix4& transformation, ObjectInstanceType3D instanceType, UnsignedInt instance, const void* importerState = nullptr); /** * @brief Constructor for empty instance * @param children Child objects * @param transformation Transformation (relative to parent) + * @param importerState Importer-specific state */ - explicit ObjectData3D(std::vector children, const Matrix4& transformation); + explicit ObjectData3D(std::vector children, const Matrix4& transformation, const void* importerState = nullptr); /** @brief Copying is not allowed */ ObjectData3D(const ObjectData3D&) = delete; @@ -115,11 +117,19 @@ class MAGNUM_EXPORT ObjectData3D { */ Int instance() const { return _instance; } + /** + * @brief Importer-specific state + * + * See @ref AbstractImporter::importerState() for more information. + */ + const void* importerState() const { return _importerState; } + private: std::vector _children; Matrix4 _transformation; ObjectInstanceType3D _instanceType; Int _instance; + const void* _importerState; }; /** @debugoperatorenum{Magnum::Trade::ObjectInstanceType3D} */ diff --git a/src/Magnum/Trade/PhongMaterialData.h b/src/Magnum/Trade/PhongMaterialData.h index f525f7e42..2e0451056 100644 --- a/src/Magnum/Trade/PhongMaterialData.h +++ b/src/Magnum/Trade/PhongMaterialData.h @@ -66,13 +66,14 @@ class MAGNUM_EXPORT PhongMaterialData: public AbstractMaterialData { /** * @brief Constructor - * @param flags Material flags - * @param shininess Shininess + * @param flags Material flags + * @param shininess Shininess + * @param importerState Importer-specific state * * Colors and textures should be specified using member functions based * on what flags are set. */ - explicit PhongMaterialData(Flags flags, Float shininess): AbstractMaterialData(MaterialType::Phong), _shininess(shininess), _flags(flags) {} + explicit PhongMaterialData(Flags flags, Float shininess, const void* importerState = nullptr): AbstractMaterialData{MaterialType::Phong, importerState}, _shininess{shininess}, _flags{flags} {} /** @brief Material flags */ Flags flags() const { return _flags; } diff --git a/src/Magnum/Trade/SceneData.cpp b/src/Magnum/Trade/SceneData.cpp index b13d6fb89..b66b55a55 100644 --- a/src/Magnum/Trade/SceneData.cpp +++ b/src/Magnum/Trade/SceneData.cpp @@ -27,7 +27,7 @@ namespace Magnum { namespace Trade { -SceneData::SceneData(std::vector children2D, std::vector children3D): _children2D(std::move(children2D)), _children3D(std::move(children3D)) {} +SceneData::SceneData(std::vector children2D, std::vector children3D, const void* const importerState): _children2D{std::move(children2D)}, _children3D{std::move(children3D)}, _importerState{importerState} {} SceneData::SceneData(SceneData&&) = default; diff --git a/src/Magnum/Trade/SceneData.h b/src/Magnum/Trade/SceneData.h index 6c4703ba5..799c3c051 100644 --- a/src/Magnum/Trade/SceneData.h +++ b/src/Magnum/Trade/SceneData.h @@ -44,10 +44,11 @@ class MAGNUM_EXPORT SceneData { public: /** * @brief Constructor - * @param children2D Two-dimensional child objects - * @param children3D Three-dimensional child objects + * @param children2D Two-dimensional child objects + * @param children3D Three-dimensional child objects + * @param importerState Importer-specific state */ - explicit SceneData(std::vector children2D, std::vector children3D); + explicit SceneData(std::vector children2D, std::vector children3D, const void* importerState = nullptr); /** @brief Copying is not allowed */ SceneData(const SceneData&) = delete; @@ -67,9 +68,17 @@ class MAGNUM_EXPORT SceneData { /** @brief Three-dimensional child objects */ const std::vector& children3D() const { return _children3D; } + /** + * @brief Importer-specific state + * + * See @ref AbstractImporter::importerState() for more information. + */ + const void* importerState() const { return _importerState; } + private: std::vector _children2D, _children3D; + const void* _importerState; }; }} diff --git a/src/Magnum/Trade/TextureData.h b/src/Magnum/Trade/TextureData.h index 89dca1998..0b83c07b8 100644 --- a/src/Magnum/Trade/TextureData.h +++ b/src/Magnum/Trade/TextureData.h @@ -60,8 +60,9 @@ class TextureData { * @param mipmapFilter Mipmap filter * @param wrapping Wrapping * @param image Texture image ID + * @param importerState Importer-specific state */ - TextureData(Type type, Sampler::Filter minificationFilter, Sampler::Filter magnificationFilter, Sampler::Mipmap mipmapFilter, Array3D wrapping, UnsignedInt image): _type(type), _minificationFilter(minificationFilter), _magnificationFilter(magnificationFilter), _mipmapFilter(mipmapFilter), _wrapping(wrapping), _image(image) {} + TextureData(Type type, Sampler::Filter minificationFilter, Sampler::Filter magnificationFilter, Sampler::Mipmap mipmapFilter, Array3D wrapping, UnsignedInt image, const void* importerState = nullptr): _type{type}, _minificationFilter{minificationFilter}, _magnificationFilter{magnificationFilter}, _mipmapFilter{mipmapFilter}, _wrapping{wrapping}, _image{image}, _importerState{importerState} {} /** @brief Copying is not allowed */ TextureData(const TextureData&) = delete; @@ -101,12 +102,20 @@ class TextureData { */ UnsignedInt image() const { return _image; } + /** + * @brief Importer-specific state + * + * See @ref AbstractImporter::importerState() for more information. + */ + const void* importerState() const { return _importerState; } + private: Type _type; Sampler::Filter _minificationFilter, _magnificationFilter; Sampler::Mipmap _mipmapFilter; Array3D _wrapping; UnsignedInt _image; + const void* _importerState; }; /** @debugoperatorclassenum{Magnum::Trade::TextureData,Magnum::Trade::TextureData::Type} */