ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Trade: provide a way to access importer-specific data from all classes.

pull/122/merge
Vladimír Vondruš 11 years ago
parent
ded598128a
commit
c0d21e2146
23 changed files with 159 additions and 44 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 7
      src/Magnum/Trade/AbstractImporter.cpp
  2. 18
      src/Magnum/Trade/AbstractImporter.h
  3. 2
      src/Magnum/Trade/AbstractMaterialData.cpp
  4. 13
      src/Magnum/Trade/AbstractMaterialData.h
  5. 22
      src/Magnum/Trade/CameraData.h
  6. 2
      src/Magnum/Trade/ImageData.cpp
  7. 32
      src/Magnum/Trade/ImageData.h
  8. 2
      src/Magnum/Trade/MeshData2D.cpp
  9. 11
      src/Magnum/Trade/MeshData2D.h
  10. 2
      src/Magnum/Trade/MeshData3D.cpp
  11. 11
      src/Magnum/Trade/MeshData3D.h
  12. 2
      src/Magnum/Trade/MeshObjectData2D.cpp
  13. 3
      src/Magnum/Trade/MeshObjectData2D.h
  14. 2
      src/Magnum/Trade/MeshObjectData3D.cpp
  15. 3
      src/Magnum/Trade/MeshObjectData3D.h
  16. 4
      src/Magnum/Trade/ObjectData2D.cpp
  17. 14
      src/Magnum/Trade/ObjectData2D.h
  18. 4
      src/Magnum/Trade/ObjectData3D.cpp
  19. 14
      src/Magnum/Trade/ObjectData3D.h
  20. 7
      src/Magnum/Trade/PhongMaterialData.h
  21. 2
      src/Magnum/Trade/SceneData.cpp
  22. 15
      src/Magnum/Trade/SceneData.h
  23. 11
      src/Magnum/Trade/TextureData.h

7
src/Magnum/Trade/AbstractImporter.cpp
Unescape View File

@ -454,4 +454,11 @@ std::optional<ImageData3D> AbstractImporter::image3D(const UnsignedInt id) {
std::optional<ImageData3D> 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; }
}}

18
src/Magnum/Trade/AbstractImporter.h
Unescape View File

@ -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<ImageData3D> doImage3D(UnsignedInt id);
/** @brief Implementation for @ref importerState() */
virtual const void* doImporterState() const;
};
CORRADE_ENUMSET_OPERATORS(AbstractImporter::Features)

2
src/Magnum/Trade/AbstractMaterialData.cpp
Unescape View File

@ -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() {}

13
src/Magnum/Trade/AbstractMaterialData.h
Unescape View File

@ -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} */

22
src/Magnum/Trade/CameraData.h
Unescape View File

@ -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} {}
}}

2
src/Magnum/Trade/ImageData.cpp
Unescape View File

@ -27,7 +27,7 @@
namespace Magnum { namespace Trade {
template<UnsignedInt dimensions> ImageData<dimensions>::ImageData(const PixelStorage storage, const PixelFormat format, const PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data): _compressed{false}, _storage{storage}, _format{format}, _type{type}, _size{size}, _data{std::move(data)} {
template<UnsignedInt dimensions> ImageData<dimensions>::ImageData(const PixelStorage storage, const PixelFormat format, const PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& 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), );
}

32
src/Magnum/Trade/ImageData.h
Unescape View File

@ -63,20 +63,21 @@ template<UnsignedInt dimensions> 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<dimensions, Int>& size, Containers::Array<char>&& data);
explicit ImageData(PixelStorage storage, PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* importerState = nullptr);
/** @overload
* Similar to the above, but uses default @ref PixelStorage parameters.
*/
explicit ImageData(PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data): ImageData{{}, format, type, size, std::move(data)} {}
explicit ImageData(PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* importerState = nullptr): ImageData{{}, format, type, size, std::move(data), importerState} {}
#ifdef MAGNUM_BUILD_DEPRECATED
/** @copybrief ImageData(PixelFormat, PixelType, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&)
* @deprecated Use @ref ImageData(PixelFormat, PixelType, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&) instead.
/** @copybrief ImageData(PixelFormat, PixelType, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&, const void*)
* @deprecated Use @ref ImageData(PixelFormat, PixelType, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&, const void*) instead.
*/
explicit CORRADE_DEPRECATED("use ImageData(PixelFormat, PixelType, const VectorTypeFor&, Containers::Array&&) instead") ImageData(PixelFormat format, PixelType type, const VectorTypeFor<dimensions, Int>& size, void* data): ImageData{format, type, size, Containers::Array<char>{reinterpret_cast<char*>(data), Magnum::Implementation::imageDataSizeFor(format, type, size)}} {}
#endif
@ -88,6 +89,7 @@ template<UnsignedInt dimensions> 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<UnsignedInt dimensions> class ImageData {
* @requires_gl Compressed pixel storage is hardcoded in OpenGL ES and
* WebGL.
*/
explicit ImageData(CompressedPixelStorage storage, CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data);
explicit ImageData(CompressedPixelStorage storage, CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* importerState = nullptr);
#endif
/**
@ -103,11 +105,12 @@ template<UnsignedInt dimensions> 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<dimensions, Int>& size, Containers::Array<char>&& data);
explicit ImageData(CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* importerState = nullptr);
/** @brief Copying is not allowed */
ImageData(const ImageData<dimensions>&) = delete;
@ -242,6 +245,13 @@ template<UnsignedInt dimensions> class ImageData {
*/
Containers::Array<char> 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<UnsignedInt dimensions> class ImageData {
PixelType _type;
Math::Vector<Dimensions, Int> _size;
Containers::Array<char> _data;
const void* _importerState;
};
/** @brief One-dimensional image */
@ -272,17 +283,17 @@ template<UnsignedInt dimensions> ImageData<dimensions>::ImageData(
#ifndef MAGNUM_TARGET_GLES
const CompressedPixelStorage storage,
#endif
const CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data): _compressed{true},
const CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& 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<UnsignedInt dimensions> inline ImageData<dimensions>::ImageData(const CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data): ImageData{{}, format, size, std::move(data)} {}
template<UnsignedInt dimensions> inline ImageData<dimensions>::ImageData(const CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>& size, Containers::Array<char>&& data, const void* const importerState): ImageData{{}, format, size, std::move(data), importerState} {}
#endif
template<UnsignedInt dimensions> inline ImageData<dimensions>::ImageData(ImageData<dimensions>&& other) noexcept: _compressed{std::move(other._compressed)}, _size{std::move(other._size)}, _data{std::move(other._data)} {
template<UnsignedInt dimensions> inline ImageData<dimensions>::ImageData(ImageData<dimensions>&& other) noexcept: _compressed{std::move(other._compressed)}, _size{std::move(other._size)}, _data{std::move(other._data)}, _importerState{std::move(other._importerState)} {
if(_compressed) {
#ifndef MAGNUM_TARGET_GLES
new(&_compressedStorage) CompressedPixelStorage{std::move(other._compressedStorage)};
@ -314,6 +325,7 @@ template<UnsignedInt dimensions> inline ImageData<dimensions>& ImageData<dimensi
swap(_type, other._type);
swap(_size, other._size);
swap(_data, other._data);
swap(_importerState, other._importerState);
return *this;
}

2
src/Magnum/Trade/MeshData2D.cpp
Unescape View File

@ -29,7 +29,7 @@
namespace Magnum { namespace Trade {
MeshData2D::MeshData2D(MeshPrimitive primitive, std::vector<UnsignedInt> indices, std::vector<std::vector<Vector2>> positions, std::vector<std::vector<Vector2>> textureCoords2D): _primitive(primitive), _indices(std::move(indices)), _positions(std::move(positions)), _textureCoords2D(std::move(textureCoords2D)) {
MeshData2D::MeshData2D(const MeshPrimitive primitive, std::vector<UnsignedInt> indices, std::vector<std::vector<Vector2>> positions, std::vector<std::vector<Vector2>> 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", );
}

11
src/Magnum/Trade/MeshData2D.h
Unescape View File

@ -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<UnsignedInt> indices, std::vector<std::vector<Vector2>> positions, std::vector<std::vector<Vector2>> textureCoords2D);
explicit MeshData2D(MeshPrimitive primitive, std::vector<UnsignedInt> indices, std::vector<std::vector<Vector2>> positions, std::vector<std::vector<Vector2>> textureCoords2D, const void* importerState = nullptr);
/** @brief Copying is not allowed */
MeshData2D(const MeshData2D&) = delete;
@ -116,11 +117,19 @@ class MAGNUM_EXPORT MeshData2D {
std::vector<Vector2>& textureCoords2D(UnsignedInt id);
const std::vector<Vector2>& 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<UnsignedInt> _indices;
std::vector<std::vector<Vector2>> _positions;
std::vector<std::vector<Vector2>> _textureCoords2D;
const void* _importerState;
};
}}

2
src/Magnum/Trade/MeshData3D.cpp
Unescape View File

@ -29,7 +29,7 @@
namespace Magnum { namespace Trade {
MeshData3D::MeshData3D(MeshPrimitive primitive, std::vector<UnsignedInt> indices, std::vector<std::vector<Vector3>> positions, std::vector<std::vector<Vector3>> normals, std::vector<std::vector<Vector2>> 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<UnsignedInt> indices, std::vector<std::vector<Vector3>> positions, std::vector<std::vector<Vector3>> normals, std::vector<std::vector<Vector2>> 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", );
}

11
src/Magnum/Trade/MeshData3D.h
Unescape View File

@ -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<UnsignedInt> indices, std::vector<std::vector<Vector3>> positions, std::vector<std::vector<Vector3>> normals, std::vector<std::vector<Vector2>> textureCoords2D);
explicit MeshData3D(MeshPrimitive primitive, std::vector<UnsignedInt> indices, std::vector<std::vector<Vector3>> positions, std::vector<std::vector<Vector3>> normals, std::vector<std::vector<Vector2>> textureCoords2D, const void* importerState = nullptr);
/** @brief Copying is not allowed */
MeshData3D(const MeshData3D&) = delete;
@ -132,12 +133,20 @@ class MAGNUM_EXPORT MeshData3D {
std::vector<Vector2>& textureCoords2D(UnsignedInt id);
const std::vector<Vector2>& 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<UnsignedInt> _indices;
std::vector<std::vector<Vector3>> _positions;
std::vector<std::vector<Vector3>> _normals;
std::vector<std::vector<Vector2>> _textureCoords2D;
const void* _importerState;
};
}}

2
src/Magnum/Trade/MeshObjectData2D.cpp
Unescape View File

@ -27,6 +27,6 @@
namespace Magnum { namespace Trade {
MeshObjectData2D::MeshObjectData2D(std::vector<UnsignedInt> children, const Matrix3& transformation, UnsignedInt instance, Int material): ObjectData2D(std::move(children), transformation, ObjectInstanceType2D::Mesh, instance), _material(material) {}
MeshObjectData2D::MeshObjectData2D(std::vector<UnsignedInt> 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} {}
}}

3
src/Magnum/Trade/MeshObjectData2D.h
Unescape View File

@ -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<UnsignedInt> children, const Matrix3& transformation, UnsignedInt instance, Int material);
explicit MeshObjectData2D(std::vector<UnsignedInt> children, const Matrix3& transformation, UnsignedInt instance, Int material, const void* importerState = nullptr);
/** @brief Copying is not allowed */
MeshObjectData2D(const MeshObjectData2D&) = delete;

2
src/Magnum/Trade/MeshObjectData3D.cpp
Unescape View File

@ -27,6 +27,6 @@
namespace Magnum { namespace Trade {
MeshObjectData3D::MeshObjectData3D(std::vector<UnsignedInt> children, const Matrix4& transformation, UnsignedInt instance, Int material): ObjectData3D(std::move(children), transformation, ObjectInstanceType3D::Mesh, instance), _material(material) {}
MeshObjectData3D::MeshObjectData3D(std::vector<UnsignedInt> 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} {}
}}

3
src/Magnum/Trade/MeshObjectData3D.h
Unescape View File

@ -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<UnsignedInt> children, const Matrix4& transformation, UnsignedInt instance, Int material);
explicit MeshObjectData3D(std::vector<UnsignedInt> children, const Matrix4& transformation, UnsignedInt instance, Int material, const void* importerState = nullptr);
/** @brief Copying is not allowed */
MeshObjectData3D(const MeshObjectData3D&) = delete;

4
src/Magnum/Trade/ObjectData2D.cpp
Unescape View File

@ -27,9 +27,9 @@
namespace Magnum { namespace Trade {
ObjectData2D::ObjectData2D(std::vector<UnsignedInt> children, const Matrix3& transformation, ObjectInstanceType2D instanceType, UnsignedInt instance): _children(std::move(children)), _transformation(transformation), _instanceType(instanceType), _instance(instance) {}
ObjectData2D::ObjectData2D(std::vector<UnsignedInt> 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<UnsignedInt> children, const Matrix3& transformation): _children(std::move(children)), _transformation(transformation), _instanceType(ObjectInstanceType2D::Empty), _instance(-1) {}
ObjectData2D::ObjectData2D(std::vector<UnsignedInt> 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;

14
src/Magnum/Trade/ObjectData2D.h
Unescape View File

@ -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<UnsignedInt> children, const Matrix3& transformation, ObjectInstanceType2D instanceType, UnsignedInt instance);
explicit ObjectData2D(std::vector<UnsignedInt> 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<UnsignedInt> children, const Matrix3& transformation);
explicit ObjectData2D(std::vector<UnsignedInt> 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<UnsignedInt> _children;
Matrix3 _transformation;
ObjectInstanceType2D _instanceType;
Int _instance;
const void* _importerState;
};
/** @debugoperatorenum{Magnum::Trade::ObjectInstanceType2D} */

4
src/Magnum/Trade/ObjectData3D.cpp
Unescape View File

@ -27,9 +27,9 @@
namespace Magnum { namespace Trade {
ObjectData3D::ObjectData3D(std::vector<UnsignedInt> children, const Matrix4& transformation, ObjectInstanceType3D instanceType, UnsignedInt instance): _children(std::move(children)), _transformation(transformation), _instanceType(instanceType), _instance(instance) {}
ObjectData3D::ObjectData3D(std::vector<UnsignedInt> 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<UnsignedInt> children, const Matrix4& transformation): _children(std::move(children)), _transformation(transformation), _instanceType(ObjectInstanceType3D::Empty), _instance(-1) {}
ObjectData3D::ObjectData3D(std::vector<UnsignedInt> 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;

14
src/Magnum/Trade/ObjectData3D.h
Unescape View File

@ -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<UnsignedInt> children, const Matrix4& transformation, ObjectInstanceType3D instanceType, UnsignedInt instance);
explicit ObjectData3D(std::vector<UnsignedInt> 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<UnsignedInt> children, const Matrix4& transformation);
explicit ObjectData3D(std::vector<UnsignedInt> 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<UnsignedInt> _children;
Matrix4 _transformation;
ObjectInstanceType3D _instanceType;
Int _instance;
const void* _importerState;
};
/** @debugoperatorenum{Magnum::Trade::ObjectInstanceType3D} */

7
src/Magnum/Trade/PhongMaterialData.h
Unescape View File

@ -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; }

2
src/Magnum/Trade/SceneData.cpp
Unescape View File

@ -27,7 +27,7 @@
namespace Magnum { namespace Trade {
SceneData::SceneData(std::vector<UnsignedInt> children2D, std::vector<UnsignedInt> children3D): _children2D(std::move(children2D)), _children3D(std::move(children3D)) {}
SceneData::SceneData(std::vector<UnsignedInt> children2D, std::vector<UnsignedInt> children3D, const void* const importerState): _children2D{std::move(children2D)}, _children3D{std::move(children3D)}, _importerState{importerState} {}
SceneData::SceneData(SceneData&&) = default;

15
src/Magnum/Trade/SceneData.h
Unescape View File

@ -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<UnsignedInt> children2D, std::vector<UnsignedInt> children3D);
explicit SceneData(std::vector<UnsignedInt> children2D, std::vector<UnsignedInt> 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<UnsignedInt>& children3D() const { return _children3D; }
/**
* @brief Importer-specific state
*
* See @ref AbstractImporter::importerState() for more information.
*/
const void* importerState() const { return _importerState; }
private:
std::vector<UnsignedInt> _children2D,
_children3D;
const void* _importerState;
};
}}

11
src/Magnum/Trade/TextureData.h
Unescape View File

@ -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<Sampler::Wrapping> 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<Sampler::Wrapping> 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<Sampler::Wrapping> _wrapping;
UnsignedInt _image;
const void* _importerState;
};
/** @debugoperatorclassenum{Magnum::Trade::TextureData,Magnum::Trade::TextureData::Type} */

Write Preview
Loading…
Cancel
Save