Magnum::Trade::AbstractImporter class
#include <Magnum/Trade/AbstractImporter.h>

Base for importer plugins.

Usage
Data dependency
Subclassing
Reference

Provides interface for importing 2D/3D scene, camera, light, animation, mesh, material, texture and image data.

Usage

Importers are most commonly implemented as plugins. For example, loading an image from the filesystem using the AnyImageImporter plugin can be done like this, completely with all error handling:

PluginManager::Manager<Trade::AbstractImporter> manager;
Containers::Pointer<Trade::AbstractImporter> importer =
    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 ...

See Loading and using plugins for more information about general plugin usage and *Importer classes in the Trade namespace for available importer plugins.

Loading data from memory, using file callbacks

Besides loading data directly from the filesystem using openFile() like shown above, it's possible to use openData() to import data from memory. Note that the particular importer implementation must support Feature::OpenData for this method to work.

Complex scene files often reference other files such as images and in that case you may want to intercept those references and load them in a custom way as well. For importers that advertise support for this with Feature::FileCallback this is done by specifying a file loading callback using setFileCallback(). The callback gets a filename, InputFileCallbackPolicy and an user pointer as parameters; returns a non-owning view on the loaded data or a Containers::NullOpt to indicate the file loading failed. For example, loading a scene from memory-mapped files could look like below. Note that the file loading callback affects openFile() as well — you don't have to load the top-level file manually and pass it to openData(), any importer supporting the callback feature handles that correctly.

struct Data {
    std::unordered_map<std::string,
        Containers::Array<const char, Utility::Directory::MapDeleter>> files;
} data;

importer->setFileCallback([](const std::string& filename,
    InputFileCallbackPolicy policy, Data& data)
        -> Containers::Optional<Containers::ArrayView<const char>>
    {
        auto found = data.files.find(filename);

        /* Discard the memory mapping, if not needed anymore */
        if(policy == InputFileCallbackPolicy::Close) {
            if(found != data.files.end()) data.files.erase(found);
            return {};
        }

        /* Load if not there yet */
        if(found == data.files.end()) found = data.files.emplace(
            filename, Utility::Directory::mapRead(filename)).first;

        return Containers::arrayView(found->second);
    }, data);

importer->openFile("scene.gltf"); // memory-maps all files

For importers that don't support Feature::FileCallback directly, the base openFile() implementation will use the file callback to pass the loaded data through to openData(), in case the importer supports at least Feature::OpenData. If the importer supports neither Feature::FileCallback nor Feature::OpenData, setFileCallback() doesn't allow the callbacks to be set.

The input file callback signature is the same for Trade::AbstractImporter and Text::AbstractFont to allow code reuse.

Internal importer state

Some importers, especially ones that make use of well-known external libraries, expose internal state through various accessors:

importerState() can expose a pointer to the global importer state for currently opened file
AbstractMaterialData::importerState() can expose importer state for given material imported by material()
AnimationData::importerState() can expose importer state for given animation imported by animation()
CameraData::importerState() can expose importer state for a camera importer by camera()
ImageData::importerState() can expose importer state for an image imported by image1D(), image2D() or image3D()
LightData::importerState() can expose importer state for a light imported by light()
MeshData3D::importerState() can expose importer state for a mesh imported by mesh2D() or mesh3D()
ObjectData3D::importerState() can expose importer state for an object imported by object2D() or object3D()
SceneData::importerState() can expose importer state for a scene imported by scene()
TextureData::importerState() can expose importer state for a texture imported by texture()

Besides exposing internal state, importers that support the Feature::OpenState feature can also attach to existing importer state using openState(). See documentation of a particular importer for details about concrete types returned and accepted by these functions.

Polymorphic imported data types

Some data access functions return Corrade::Containers::Pointer instead of Corrade::Containers::Optional because the result might be a particular subclass of given type. Those functions are material(), object2D() and object3D(). You can cast the abstract base to a concrete type depending on its reported type, for example:

Containers::Pointer<Trade::AbstractMaterialData> data = importer->material(12);
if(data && data->type() == Trade::MaterialType::Phong) {
    auto& phong = static_cast<Trade::PhongMaterialData&>(*data);

    shininess = phong.shininess();
    // ...
}

Another option is making use of the Containers::pointerCast() utility, but note that in that case the original Corrade::Containers::Pointer will be moved into a new instance and that might not be desirable.

Data dependency

The *Data instances returned from various functions by design have no dependency on the importer instance and neither on the dynamic plugin module. In other words, you don't need to keep the importer instance (or the plugin manager instance) around in order to have the *Data instances valid. Moreover, all Corrade::Containers::Array instances returned through ImageData, AnimationData and others are only allowed to have default deleters — this is to avoid potential dangling function pointer calls when destructing such instances after the plugin module has been unloaded.

The only exception are various importerState() functions described above, but in that case the relation is weak — these are valid only as long as the currently opened file is kept open. If the file gets closed or the importer instance deleted, the state pointers become dangling, and that's fine as long as you don't access them.

Subclassing

The plugin needs to implement the doFeatures(), doIsOpened() functions, at least one of doOpenData() / doOpenFile() / doOpenState() functions, function doClose() and one or more tuples of data access functions, based on what features are supported in given format.

In order to support Feature::FileCallback, the importer needs to properly use the callbacks to both load the top-level file in doOpenFile() and also load any external files when needed. The doOpenFile() can delegate back into the base implementation, but it should remember at least the base file path to pass correct paths to subsequent file callbacks. The doSetFileCallback() can be overriden in case it's desired to respond to file loading callback setup, but doesn't have to be.

For multi-data formats the file opening shouldn't take long and all parsing should be done in the data parsing functions instead, because the user might want to import only some data. This is obviously not the case for single-data formats like images, as the file contains all the data the user wants to import.

You don't need to do most of the redundant sanity checks, these things are checked by the implementation:

The doOpenData(), doOpenFile() and doOpenState() functions are called after the previous file was closed, function doClose() is called only if there is any file opened.
The doOpenData() function is called only if Feature::OpenData is supported.
The doOpenState() function is called only if Feature::OpenState is supported.
The doSetFileCallback() function is called only if Feature::FileCallback is supported and there is no file opened.
All do*() implementations working on an opened file are called only if there is any file opened.
All do*() implementations taking data ID as parameter are called only if the ID is from valid range.

Dangling function pointers on plugin unload

As mentioned above, Corrade::Containers::Array instances returned from plugin implementations are not allowed to use anything else than the default deleter, otherwise this could cause dangling function pointer call on array destruction if the plugin gets unloaded before the array is destroyed. This is asserted by the base implementation on return.

Similarly for interpolator functions passed through Animation::TrackView instances to AnimationData — to avoid dangling pointers, be sure to always include an interpolator returned from animationInterpolatorFor(), which guarantees the function is not instantiated in the plugin binary. Avoid using Animation::interpolatorFor() (or indirectly using it by specifying just Animation::Interpolation), as it doesn't have such a guarantee. Note that unlike with array instances, the base implementation can't easily check for this.

Derived classes

class AnyImageImporter: Any image importer plugin.
class AnySceneImporter: Any scene importer plugin.
class AssimpImporter: Assimp importer.
class BasisImporter new in 2019.10: Basis Universal importer plugin.
class DdsImporter: DDS image importer plugin.
class DevIlImageImporter: DevIL Image importer plugin.
class JpegImporter: JPEG importer plugin.
class ObjImporter: OBJ importer plugin.
class OpenGexImporter: OpenGEX importer.
class PngImporter: PNG importer plugin.
class StanfordImporter: Stanford PLY importer plugin.
class StbImageImporter: Image importer plugin using stb_image.
class TgaImporter: TGA importer plugin.
class TinyGltfImporter: TinyGltf importer plugin.

Public types

enum class Feature: UnsignedByte { OpenData = 1 << 0, OpenState = 1 << 1, FileCallback = 1 << 2 }: Features supported by this importer.
using Features = Containers::EnumSet<Feature>: Set of features supported by this importer.

Public static functions

static auto pluginInterface() -> std::string: Plugin interface.
static auto pluginSearchPaths() -> std::vector<std::string>: Plugin search paths.

Constructors, destructors, conversion operators

AbstractImporter() explicit: Default constructor.
AbstractImporter(PluginManager::Manager<AbstractImporter>& manager) explicit: Constructor with access to plugin manager.
AbstractImporter(PluginManager::AbstractManager& manager, const std::string& plugin) explicit: Plugin manager constructor.

Public functions

auto features() const -> Features: Features supported by this importer.
auto fileCallback() -> auto: File opening callback function.
auto fileCallbackUserData() const -> void*: File opening callback user data.
void setFileCallback(Containers::Optional<Containers::ArrayView<const char>>(*)(const std::string&, InputFileCallbackPolicy, void*) callback, void* userData = nullptr): Set file opening callback.
template<class T> void setFileCallback(Containers::Optional<Containers::ArrayView<const char>>(*)(const std::string&, InputFileCallbackPolicy, T&) callback, T& userData): Set file opening callback.
auto isOpened() const -> bool: Whether any file is opened.
auto openData(Containers::ArrayView<const char> data) -> bool: Open raw data.
auto openState(const void* state, const std::string& filePath = {}) -> bool: Open already loaded state.
auto openFile(const std::string& filename) -> bool: Open a file.
void close(): Close currently opened file.

Data accessors

Each function tuple provides access to given data.

auto defaultScene() -> Int: Default scene.
auto sceneCount() const -> UnsignedInt: Scene count.
auto sceneForName(const std::string& name) -> Int: Scene ID for given name.
auto sceneName(UnsignedInt id) -> std::string: Scene name.
auto scene(UnsignedInt id) -> Containers::Optional<SceneData>: Scene.
auto animationCount() const -> UnsignedInt: Animation count.
auto animationForName(const std::string& name) -> Int: Animation ID for given name.
auto animationName(UnsignedInt id) -> std::string: Animation name.
auto animation(UnsignedInt id) -> Containers::Optional<AnimationData>: Animation.
auto lightCount() const -> UnsignedInt: Light count.
auto lightForName(const std::string& name) -> Int: Light ID for given name.
auto lightName(UnsignedInt id) -> std::string: Light name.
auto light(UnsignedInt id) -> Containers::Optional<LightData>: Light.
auto cameraCount() const -> UnsignedInt: Camera count.
auto cameraForName(const std::string& name) -> Int: Camera ID for given name.
auto cameraName(UnsignedInt id) -> std::string: Camera name.
auto camera(UnsignedInt id) -> Containers::Optional<CameraData>: Camera.
auto object2DCount() const -> UnsignedInt: Two-dimensional object count.
auto object2DForName(const std::string& name) -> Int: Two-dimensional object ID for given name.
auto object2DName(UnsignedInt id) -> std::string: Two-dimensional object name.
auto object2D(UnsignedInt id) -> Containers::Pointer<ObjectData2D>: Two-dimensional object.
auto object3DCount() const -> UnsignedInt: Three-dimensional object count.
auto object3DForName(const std::string& name) -> Int: Three-dimensional object ID for given name.
auto object3DName(UnsignedInt id) -> std::string: Three-dimensional object name.
auto object3D(UnsignedInt id) -> Containers::Pointer<ObjectData3D>: Three-dimensional object.
auto mesh2DCount() const -> UnsignedInt: Two-dimensional mesh count.
auto mesh2DForName(const std::string& name) -> Int: Two-dimensional mesh ID for given name.
auto mesh2DName(UnsignedInt id) -> std::string: Two-dimensional mesh name.
auto mesh2D(UnsignedInt id) -> Containers::Optional<MeshData2D>: Two-dimensional mesh.
auto mesh3DCount() const -> UnsignedInt: Three-dimensional mesh count.
auto mesh3DForName(const std::string& name) -> Int: Three-dimensional mesh ID for given name.
auto mesh3DName(UnsignedInt id) -> std::string: Three-dimensional mesh name.
auto mesh3D(UnsignedInt id) -> Containers::Optional<MeshData3D>: Three-dimensional mesh.
auto materialCount() const -> UnsignedInt: Material count.
auto materialForName(const std::string& name) -> Int: Material ID for given name.
auto materialName(UnsignedInt id) -> std::string: Material name.
auto material(UnsignedInt id) -> Containers::Pointer<AbstractMaterialData>: Material.
auto textureCount() const -> UnsignedInt: Texture count.
auto textureForName(const std::string& name) -> Int: Texture ID for given name.
auto textureName(UnsignedInt id) -> std::string: Texture name.
auto texture(UnsignedInt id) -> Containers::Optional<TextureData>: Texture.
auto image1DCount() const -> UnsignedInt: One-dimensional image count.
auto image1DForName(const std::string& name) -> Int: One-dimensional image ID for given name.
auto image1DName(UnsignedInt id) -> std::string: One-dimensional image name.
auto image1D(UnsignedInt id) -> Containers::Optional<ImageData1D>: One-dimensional image.
auto image2DCount() const -> UnsignedInt: Two-dimensional image count.
auto image2DForName(const std::string& name) -> Int: Two-dimensional image ID for given name.
auto image2DName(UnsignedInt id) -> std::string: Two-dimensional image name.
auto image2D(UnsignedInt id) -> Containers::Optional<ImageData2D>: Two-dimensional image.
auto image3DCount() const -> UnsignedInt: Three-dimensional image count.
auto image3DForName(const std::string& name) -> Int: Three-dimensional image ID for given name.
auto image3DName(UnsignedInt id) -> std::string: Three-dimensional image name.
auto image3D(UnsignedInt id) -> Containers::Optional<ImageData3D>: Three-dimensional image.
auto importerState() const -> const void*: Plugin-specific access to internal importer state.
void doOpenFile(const std::string& filename) protected virtual: Implementation for openFile()
auto doFeatures() const -> Features private pure virtual: Implementation for features()
void doSetFileCallback(Containers::Optional<Containers::ArrayView<const char>>(*)(const std::string&, InputFileCallbackPolicy, void*) callback, void* userData) private virtual: Implementation for setFileCallback()
auto doIsOpened() const -> bool private pure virtual: Implementation for isOpened()
void doOpenData(Containers::ArrayView<const char> data) private virtual: Implementation for openData()
void doOpenState(const void* state, const std::string& filePath) private virtual: Implementation for openState()
void doClose() private pure virtual: Implementation for close()
auto doDefaultScene() -> Int private virtual: Implementation for defaultScene()
auto doSceneCount() const -> UnsignedInt private virtual: Implementation for sceneCount()
auto doSceneForName(const std::string& name) -> Int private virtual: Implementation for sceneForName()
auto doSceneName(UnsignedInt id) -> std::string private virtual: Implementation for sceneName()
auto doScene(UnsignedInt id) -> Containers::Optional<SceneData> private virtual: Implementation for scene()
auto doAnimationCount() const -> UnsignedInt private virtual: Implementation for animationCount()
auto doAnimationForName(const std::string& name) -> Int private virtual: Implementation for animationForName()
auto doAnimationName(UnsignedInt id) -> std::string private virtual: Implementation for animationName()
auto doAnimation(UnsignedInt id) -> Containers::Optional<AnimationData> private virtual: Implementation for animation()
auto doLightCount() const -> UnsignedInt private virtual: Implementation for lightCount()
auto doLightForName(const std::string& name) -> Int private virtual: Implementation for lightForName()
auto doLightName(UnsignedInt id) -> std::string private virtual: Implementation for lightName()
auto doLight(UnsignedInt id) -> Containers::Optional<LightData> private virtual: Implementation for light()
auto doCameraCount() const -> UnsignedInt private virtual: Implementation for cameraCount()
auto doCameraForName(const std::string& name) -> Int private virtual: Implementation for cameraForName()
auto doCameraName(UnsignedInt id) -> std::string private virtual: Implementation for cameraName()
auto doCamera(UnsignedInt id) -> Containers::Optional<CameraData> private virtual: Implementation for camera()
auto doObject2DCount() const -> UnsignedInt private virtual: Implementation for object2DCount()
auto doObject2DForName(const std::string& name) -> Int private virtual: Implementation for object2DForName()
auto doObject2DName(UnsignedInt id) -> std::string private virtual: Implementation for object2DName()
auto doObject2D(UnsignedInt id) -> Containers::Pointer<ObjectData2D> private virtual: Implementation for object2D()
auto doObject3DCount() const -> UnsignedInt private virtual: Implementation for object3DCount()
auto doObject3DForName(const std::string& name) -> Int private virtual: Implementation for object3DForName()
auto doObject3DName(UnsignedInt id) -> std::string private virtual: Implementation for object3DName()
auto doObject3D(UnsignedInt id) -> Containers::Pointer<ObjectData3D> private virtual: Implementation for object3D()
auto doMesh2DCount() const -> UnsignedInt private virtual: Implementation for mesh2DCount()
auto doMesh2DForName(const std::string& name) -> Int private virtual: Implementation for mesh2DForName()
auto doMesh2DName(UnsignedInt id) -> std::string private virtual: Implementation for mesh2DName()
auto doMesh2D(UnsignedInt id) -> Containers::Optional<MeshData2D> private virtual: Implementation for mesh2D()
auto doMesh3DCount() const -> UnsignedInt private virtual: Implementation for mesh3DCount()
auto doMesh3DForName(const std::string& name) -> Int private virtual: Implementation for mesh3DForName()
auto doMesh3DName(UnsignedInt id) -> std::string private virtual: Implementation for mesh3DName()
auto doMesh3D(UnsignedInt id) -> Containers::Optional<MeshData3D> private virtual: Implementation for mesh3D()
auto doMaterialCount() const -> UnsignedInt private virtual: Implementation for materialCount()
auto doMaterialForName(const std::string& name) -> Int private virtual: Implementation for materialForName()
auto doMaterialName(UnsignedInt id) -> std::string private virtual: Implementation for materialName()
auto doMaterial(UnsignedInt id) -> Containers::Pointer<AbstractMaterialData> private virtual: Implementation for material()
auto doTextureCount() const -> UnsignedInt private virtual: Implementation for textureCount()
auto doTextureForName(const std::string& name) -> Int private virtual: Implementation for textureForName()
auto doTextureName(UnsignedInt id) -> std::string private virtual: Implementation for textureName()
auto doTexture(UnsignedInt id) -> Containers::Optional<TextureData> private virtual: Implementation for texture()
auto doImage1DCount() const -> UnsignedInt private virtual: Implementation for image1DCount()
auto doImage1DForName(const std::string& name) -> Int private virtual: Implementation for image1DForName()
auto doImage1DName(UnsignedInt id) -> std::string private virtual: Implementation for image1DName()
auto doImage1D(UnsignedInt id) -> Containers::Optional<ImageData1D> private virtual: Implementation for image1D()
auto doImage2DCount() const -> UnsignedInt private virtual: Implementation for image2DCount()
auto doImage2DForName(const std::string& name) -> Int private virtual: Implementation for image2DForName()
auto doImage2DName(UnsignedInt id) -> std::string private virtual: Implementation for image2DName()
auto doImage2D(UnsignedInt id) -> Containers::Optional<ImageData2D> private virtual: Implementation for image2D()
auto doImage3DCount() const -> UnsignedInt private virtual: Implementation for image3DCount()
auto doImage3DForName(const std::string& name) -> Int private virtual: Implementation for image3DForName()
auto doImage3DName(UnsignedInt id) -> std::string private virtual: Implementation for image3DName()
auto doImage3D(UnsignedInt id) -> Containers::Optional<ImageData3D> private virtual: Implementation for image3D()
auto doImporterState() const -> const void* private virtual: Implementation for importerState()

Enum documentation

enum class Magnum::Trade::AbstractImporter::Feature: UnsignedByte

Features supported by this importer.

Enumerators
OpenData	Opening files from raw data using openData()
OpenState	Opening already loaded state using openState()
FileCallback	Specifying callbacks for loading additional files referenced from the main file using setFileCallback(). If the importer doesn't expose this feature, the format is either single-file or loading via callbacks is not supported. See Loading data from memory, using file callbacks and particular importer documentation for more information.

Enumerators

OpenData

Opening files from raw data using openData()

OpenState

Opening already loaded state using openState()

FileCallback

Specifying callbacks for loading additional files referenced from the main file using setFileCallback(). If the importer doesn't expose this feature, the format is either single-file or loading via callbacks is not supported.

See Loading data from memory, using file callbacks and particular importer documentation for more information.

Typedef documentation

typedef Containers::EnumSet<Feature> Magnum::Trade::AbstractImporter::Features

Set of features supported by this importer.

Function documentation

static std::string Magnum::Trade::AbstractImporter::pluginInterface()

Plugin interface.

"cz.mosra.magnum.Trade.AbstractImporter/0.3"

static std::vector<std::string> Magnum::Trade::AbstractImporter::pluginSearchPaths()

Plugin search paths.

First looks in magnum/importers/ or magnum-d/importers/ next to the executable (or, in case of Windows and a non-static build, next to the DLL of the Trade library) and as a fallback in magnum/importers/ or magnum-d/importers/ in the runtime install location (lib[64]/ on Unix-like systems, bin/ on Windows). The system-wide plugin search directory is configurable using the MAGNUM_PLUGINS_DIR CMake variables, see Downloading and building for more information.

Not defined on platforms without dynamic plugin support.

auto Magnum::Trade::AbstractImporter::fileCallback()

File opening callback function.

void* Magnum::Trade::AbstractImporter::fileCallbackUserData() const

File opening callback user data.

void Magnum::Trade::AbstractImporter::setFileCallback(Containers::Optional<Containers::ArrayView<const char>>()(const std::string&, InputFileCallbackPolicy, void) callback, void* userData = nullptr)

Set file opening callback.

In case the importer supports Feature::FileCallback, files opened through openFile() will be loaded through the provided callback. Besides that, all external files referenced by the top-level file will be loaded through the callback function as well, usually on demand. The callback function gets a filename, InputFileCallbackPolicy and the userData pointer as input and returns a non-owning view on the loaded data as output or a Corrade::Containers::NullOpt if loading failed — because empty files might also be valid in some circumstances, nullptr can't be used to indicate a failure.

In case the importer doesn't support Feature::FileCallback but supports at least Feature::OpenData, a file opened through openFile() will be internally loaded through the provided callback and then passed to openData(). First the file is loaded with InputFileCallbackPolicy::LoadTemporary passed to the callback, then the returned memory view is passed to openData() (sidestepping the potential openFile() implementation of that particular importer) and after that the callback is called again with InputFileCallbackPolicy::Close because the semantics of openData() don't require the data to be alive after. In case you need a different behavior, use openData() directly.

In case callback is nullptr, the current callback (if any) is reset. This function expects that the importer supports either Feature::FileCallback or Feature::OpenData. If an importer supports neither, callbacks can't be used.

It's expected that this function is called before a file is opened. It's also expected that the loaded data are kept in scope for as long as the importer needs them, based on the value of InputFileCallbackPolicy. Documentation of particular importers provides more information about the expected callback behavior.

Following is an example of setting up a file loading callback for fetching compiled-in resources from Corrade::Utility::Resource. See the overload below for a more convenient type-safe way to pass the user data pointer.

importer->setFileCallback([](const std::string& filename,
    InputFileCallbackPolicy, void*) {
        Utility::Resource rs("data");
        return Containers::optional(rs.getRaw(filename));
    });

template<class T>
void Magnum::Trade::AbstractImporter::setFileCallback(Containers::Optional<Containers::ArrayView<const char>>(*)(const std::string&, InputFileCallbackPolicy, T&) callback, T& userData)

Set file opening callback.

Equivalent to calling the above with a lambda wrapper that casts void* back to T* and dereferences it in order to pass it to callback. Example usage:

struct Data {
    std::unordered_map<std::string, Containers::Array<char>> files;
} data;

importer->setFileCallback([](const std::string& filename,
    InputFileCallbackPolicy, Data& data)
        -> Containers::Optional<Containers::ArrayView<const char>>
    {
        auto found = data.files.find(filename);
        if(found == data.files.end()) {
            if(!Utility::Directory::exists(filename))
                return Containers::NullOpt;
            found = data.files.emplace(filename, Utility::Directory::read(filename)).first;
        }
        return Containers::ArrayView<const char>{found->second};
    }, data);

bool Magnum::Trade::AbstractImporter::openData(Containers::ArrayView<const char> data)

Open raw data.

Closes previous file, if it was opened, and tries to open given raw data. Available only if Feature::OpenData is supported. Returns true on success, false otherwise. The data is not expected to be alive after the function exits.

bool Magnum::Trade::AbstractImporter::openState(const void* state, const std::string& filePath = {})

Open already loaded state.

Parameters
state	Pointer to importer-specific state
filePath	Base file directory for opening external data like textures and materials.

Closes previous file, if it was opened, and tries to open given state. Available only if Feature::OpenState is supported. Returns true on success, false otherwise.

See documentation of a particular plugin for more information about type and contents of the state parameter.

bool Magnum::Trade::AbstractImporter::openFile(const std::string& filename)

Open a file.

Closes previous file, if it was opened, and tries to open given file. Returns true on success, false otherwise. If file loading callbacks are set via setFileCallback() and Feature::OpenData is supported, this function uses the callback to load the file and passes the memory view to openData() instead. See setFileCallback() for more information.

void Magnum::Trade::AbstractImporter::close()

Close currently opened file.

On particular implementations an explicit call to this function may result in freed memory. This call is also done automatically when the importer gets destructed or when another file is opened.

Int Magnum::Trade::AbstractImporter::defaultScene()

Default scene.

When there is more than one scene, returns ID of the default one. If there is no default scene, returns -1. Expects that a file is opened.

UnsignedInt Magnum::Trade::AbstractImporter::sceneCount() const

Scene count.

Expects that a file is opened.

Int Magnum::Trade::AbstractImporter::sceneForName(const std::string& name)

Scene ID for given name.

If no scene for given name exists, returns -1. Expects that a file is opened.

std::string Magnum::Trade::AbstractImporter::sceneName(UnsignedInt id)

Scene name.

Parameters
id	Scene ID, from range [0, sceneCount()).

Expects that a file is opened.

Containers::Optional<SceneData> Magnum::Trade::AbstractImporter::scene(UnsignedInt id)

Scene.

Parameters
id	Scene ID, from range [0, sceneCount()).

Returns given scene or Containers::NullOpt if import failed. Expects that a file is opened.

UnsignedInt Magnum::Trade::AbstractImporter::animationCount() const

Animation count.

Expects that a file is opened.

Int Magnum::Trade::AbstractImporter::animationForName(const std::string& name)

Animation ID for given name.

If no animation for given name exists, returns -1. Expects that a file is opened.

std::string Magnum::Trade::AbstractImporter::animationName(UnsignedInt id)

Animation name.

Parameters
id	Animation ID, from range [0, animationCount()).

Expects that a file is opened.

Containers::Optional<AnimationData> Magnum::Trade::AbstractImporter::animation(UnsignedInt id)

Animation.

Parameters
id	Animation ID, from range [0, animationCount()).

Returns given animation or Containers::NullOpt if importing failed. Expects that a file is opened.

UnsignedInt Magnum::Trade::AbstractImporter::lightCount() const

Light count.

Expects that a file is opened.

Int Magnum::Trade::AbstractImporter::lightForName(const std::string& name)

Light ID for given name.

If no light for given name exists, returns -1. Expects that a file is opened.

std::string Magnum::Trade::AbstractImporter::lightName(UnsignedInt id)

Light name.

Parameters
id	Light ID, from range [0, lightCount()).

Expects that a file is opened.

Containers::Optional<LightData> Magnum::Trade::AbstractImporter::light(UnsignedInt id)

Light.

Parameters
id	Light ID, from range [0, lightCount()).

Returns given light or Containers::NullOpt if importing failed. Expects that a file is opened.

UnsignedInt Magnum::Trade::AbstractImporter::cameraCount() const

Camera count.

Expects that a file is opened.

Int Magnum::Trade::AbstractImporter::cameraForName(const std::string& name)

Camera ID for given name.

If no camera for given name exists, returns -1. Expects that a file is opened.

std::string Magnum::Trade::AbstractImporter::cameraName(UnsignedInt id)

Camera name.

Parameters
id	Camera ID, from range [0, cameraCount()).

Expects that a file is opened.

Containers::Optional<CameraData> Magnum::Trade::AbstractImporter::camera(UnsignedInt id)

Camera.

Parameters
id	Camera ID, from range [0, cameraCount()).

Returns given camera or Containers::NullOpt if importing failed. Expects that a file is opened.

UnsignedInt Magnum::Trade::AbstractImporter::object2DCount() const

Two-dimensional object count.

Expects that a file is opened.

Int Magnum::Trade::AbstractImporter::object2DForName(const std::string& name)

Two-dimensional object ID for given name.

If no scene for given name exists, returns -1. Expects that a file is opened.

std::string Magnum::Trade::AbstractImporter::object2DName(UnsignedInt id)

Two-dimensional object name.

Parameters
id	Object ID, from range [0, object2DCount()).

Expects that a file is opened.

Containers::Pointer<ObjectData2D> Magnum::Trade::AbstractImporter::object2D(UnsignedInt id)

Two-dimensional object.

Parameters
id	Object ID, from range [0, object2DCount()).

Returns given object or nullptr if importing failed. Expects that a file is opened.

UnsignedInt Magnum::Trade::AbstractImporter::object3DCount() const

Three-dimensional object count.

Expects that a file is opened.

Int Magnum::Trade::AbstractImporter::object3DForName(const std::string& name)

Three-dimensional object ID for given name.

If no scene for given name exists, returns -1. Expects that a file is opened.

std::string Magnum::Trade::AbstractImporter::object3DName(UnsignedInt id)

Three-dimensional object name.

Parameters
id	Object ID, from range [0, object3DCount()).

Expects that a file is opened.

Containers::Pointer<ObjectData3D> Magnum::Trade::AbstractImporter::object3D(UnsignedInt id)

Three-dimensional object.

Parameters
id	Object ID, from range [0, object3DCount()).

Returns given object or nullptr if importing failed. Expects that a file is opened.

UnsignedInt Magnum::Trade::AbstractImporter::mesh2DCount() const

Two-dimensional mesh count.

Expects that a file is opened.

Int Magnum::Trade::AbstractImporter::mesh2DForName(const std::string& name)

Two-dimensional mesh ID for given name.

If no mesh for given name exists, returns -1. Expects that a file is opened.

std::string Magnum::Trade::AbstractImporter::mesh2DName(UnsignedInt id)

Two-dimensional mesh name.

Parameters
id	Mesh ID, from range [0, mesh2DCount()).

Expects that a file is opened.

Containers::Optional<MeshData2D> Magnum::Trade::AbstractImporter::mesh2D(UnsignedInt id)

Two-dimensional mesh.

Parameters
id	Mesh ID, from range [0, mesh2DCount()).

Returns given mesh or Containers::NullOpt if importing failed. Expects that a file is opened.

Int Magnum::Trade::AbstractImporter::mesh3DForName(const std::string& name)

Three-dimensional mesh ID for given name.

If no mesh for given name exists, returns -1. Expects that a file is opened.

std::string Magnum::Trade::AbstractImporter::mesh3DName(UnsignedInt id)

Three-dimensional mesh name.

Parameters
id	Mesh ID, from range [0, mesh3DCount()).

Expects that a file is opened.

Containers::Optional<MeshData3D> Magnum::Trade::AbstractImporter::mesh3D(UnsignedInt id)

Three-dimensional mesh.

Parameters
id	Mesh ID, from range [0, mesh3DCount()).

Returns given mesh or Containers::NullOpt if importing failed. Expects that a file is opened.

UnsignedInt Magnum::Trade::AbstractImporter::materialCount() const

Material count.

Expects that a file is opened.

Int Magnum::Trade::AbstractImporter::materialForName(const std::string& name)

Material ID for given name.

If no material for given name exists, returns -1. Expects that a file is opened.

std::string Magnum::Trade::AbstractImporter::materialName(UnsignedInt id)

Material name.

Parameters
id	Material ID, from range [0, materialCount()).

Expects that a file is opened.

Containers::Pointer<AbstractMaterialData> Magnum::Trade::AbstractImporter::material(UnsignedInt id)

Material.

Parameters
id	Material ID, from range [0, materialCount()).

Returns given material or nullptr if importing failed. Expects that a file is opened.

UnsignedInt Magnum::Trade::AbstractImporter::textureCount() const

Texture count.

Expects that a file is opened.

Int Magnum::Trade::AbstractImporter::textureForName(const std::string& name)

Texture ID for given name.

If no texture for given name exists, returns -1. Expects that a file is opened.

std::string Magnum::Trade::AbstractImporter::textureName(UnsignedInt id)

Texture name.

Parameters
id	Texture ID, from range [0, textureCount()).

Expects that a file is opened.

Containers::Optional<TextureData> Magnum::Trade::AbstractImporter::texture(UnsignedInt id)

Texture.

Parameters
id	Texture ID, from range [0, textureCount()).

Returns given texture or Containers::NullOpt if importing failed. Expects that a file is opened.

UnsignedInt Magnum::Trade::AbstractImporter::image1DCount() const

One-dimensional image count.

Expects that a file is opened.

Int Magnum::Trade::AbstractImporter::image1DForName(const std::string& name)

One-dimensional image ID for given name.

If no image for given name exists, returns -1. Expects that a file is opened.

std::string Magnum::Trade::AbstractImporter::image1DName(UnsignedInt id)

One-dimensional image name.

Parameters
id	Image ID, from range [0, image1DCount()).

Expects that a file is opened.

Containers::Optional<ImageData1D> Magnum::Trade::AbstractImporter::image1D(UnsignedInt id)

One-dimensional image.

Parameters
id	Image ID, from range [0, image1DCount()).

Returns given image or Containers::NullOpt if importing failed. Expects that a file is opened.

UnsignedInt Magnum::Trade::AbstractImporter::image2DCount() const

Two-dimensional image count.

Expects that a file is opened.

Int Magnum::Trade::AbstractImporter::image2DForName(const std::string& name)

Two-dimensional image ID for given name.

If no image for given name exists, returns -1. Expects that a file is opened.

std::string Magnum::Trade::AbstractImporter::image2DName(UnsignedInt id)

Two-dimensional image name.

Parameters
id	Image ID, from range [0, image2DCount()).

Expects that a file is opened.

Containers::Optional<ImageData2D> Magnum::Trade::AbstractImporter::image2D(UnsignedInt id)

Two-dimensional image.

Parameters
id	Image ID, from range [0, image2DCount()).

Returns given image or Containers::NullOpt if importing failed. Expects that a file is opened.

UnsignedInt Magnum::Trade::AbstractImporter::image3DCount() const

Three-dimensional image count.

Expects that a file is opened.

Int Magnum::Trade::AbstractImporter::image3DForName(const std::string& name)

Three-dimensional image ID for given name.

If no image for given name exists, returns -1. Expects that a file is opened.

std::string Magnum::Trade::AbstractImporter::image3DName(UnsignedInt id)

Three-dimensional image name.

Parameters
id	Image ID, from range [0, image3DCount()).

Expects that a file is opened.

Containers::Optional<ImageData3D> Magnum::Trade::AbstractImporter::image3D(UnsignedInt id)

Three-dimensional image.

Parameters
id	Image ID, from range [0, image3DCount()).

Returns given image or Containers::NullOpt if importing failed. Expects that a file is opened.

const void* Magnum::Trade::AbstractImporter::importerState() const

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 a particular plugin for more information about returned type and contents. Returns nullptr by default.

void Magnum::Trade::AbstractImporter::doOpenFile(const std::string& filename) virtual protected

Implementation for openFile()

If Feature::OpenData is supported, default implementation opens the file and calls doOpenData() with its contents. It is allowed to call this function from your doOpenFile() implementation — in particular, this implementation will also correctly handle callbacks set through setFileCallback().

This function is not called when file callbacks are set through setFileCallback() and Feature::FileCallback is not supported — instead, file is loaded though the callback and data passed through to doOpenData().

void Magnum::Trade::AbstractImporter::doSetFileCallback(Containers::Optional<Containers::ArrayView<const char>>()(const std::string&, InputFileCallbackPolicy, void) callback, void* userData) virtual private

Implementation for setFileCallback()

Useful when the importer needs to modify some internal state on callback setup. Default implementation does nothing and this function doesn't need to be implemented — the callback function and user data pointer are available through fileCallback() and fileCallbackUserData().

Int Magnum::Trade::AbstractImporter::doDefaultScene() virtual private

Implementation for defaultScene()

Default implementation returns -1.

UnsignedInt Magnum::Trade::AbstractImporter::doSceneCount() const virtual private

Implementation for sceneCount()

Default implementation returns 0.

Int Magnum::Trade::AbstractImporter::doSceneForName(const std::string& name) virtual private

Implementation for sceneForName()

Default implementation returns -1.

std::string Magnum::Trade::AbstractImporter::doSceneName(UnsignedInt id) virtual private

Implementation for sceneName()

Default implementation returns empty string.

UnsignedInt Magnum::Trade::AbstractImporter::doAnimationCount() const virtual private

Implementation for animationCount()

Default implementation returns 0.

Int Magnum::Trade::AbstractImporter::doAnimationForName(const std::string& name) virtual private

Implementation for animationForName()

Default implementation returns -1.

std::string Magnum::Trade::AbstractImporter::doAnimationName(UnsignedInt id) virtual private

Implementation for animationName()

Default implementation returns empty string.

UnsignedInt Magnum::Trade::AbstractImporter::doLightCount() const virtual private

Implementation for lightCount()

Default implementation returns 0.

Int Magnum::Trade::AbstractImporter::doLightForName(const std::string& name) virtual private

Implementation for lightForName()

Default implementation returns -1.

std::string Magnum::Trade::AbstractImporter::doLightName(UnsignedInt id) virtual private

Implementation for lightName()

Default implementation returns empty string.

UnsignedInt Magnum::Trade::AbstractImporter::doCameraCount() const virtual private

Implementation for cameraCount()

Default implementation returns 0.

Int Magnum::Trade::AbstractImporter::doCameraForName(const std::string& name) virtual private

Implementation for cameraForName()

Default implementation returns -1.

std::string Magnum::Trade::AbstractImporter::doCameraName(UnsignedInt id) virtual private

Implementation for cameraName()

Default implementation returns empty string.

UnsignedInt Magnum::Trade::AbstractImporter::doObject2DCount() const virtual private

Implementation for object2DCount()

Default implementation returns 0.

Int Magnum::Trade::AbstractImporter::doObject2DForName(const std::string& name) virtual private

Implementation for object2DForName()

Default implementation returns -1.

std::string Magnum::Trade::AbstractImporter::doObject2DName(UnsignedInt id) virtual private

Implementation for object2DName()

Default implementation returns empty string.

UnsignedInt Magnum::Trade::AbstractImporter::doObject3DCount() const virtual private

Implementation for object3DCount()

Default implementation returns 0.

Int Magnum::Trade::AbstractImporter::doObject3DForName(const std::string& name) virtual private

Implementation for object3DForName()

Default implementation returns -1.

std::string Magnum::Trade::AbstractImporter::doObject3DName(UnsignedInt id) virtual private

Implementation for object3DName()

Default implementation returns empty string.

UnsignedInt Magnum::Trade::AbstractImporter::doMesh2DCount() const virtual private

Implementation for mesh2DCount()

Default implementation returns 0.

Int Magnum::Trade::AbstractImporter::doMesh2DForName(const std::string& name) virtual private

Implementation for mesh2DForName()

Default implementation returns -1.

std::string Magnum::Trade::AbstractImporter::doMesh2DName(UnsignedInt id) virtual private

Implementation for mesh2DName()

Default implementation returns empty string.

UnsignedInt Magnum::Trade::AbstractImporter::doMesh3DCount() const virtual private

Implementation for mesh3DCount()

Default implementation returns 0.

Int Magnum::Trade::AbstractImporter::doMesh3DForName(const std::string& name) virtual private

Implementation for mesh3DForName()

Default implementation returns -1.

std::string Magnum::Trade::AbstractImporter::doMesh3DName(UnsignedInt id) virtual private

Implementation for mesh3DName()

Default implementation returns empty string.

UnsignedInt Magnum::Trade::AbstractImporter::doMaterialCount() const virtual private

Implementation for materialCount()

Default implementation returns 0.

Int Magnum::Trade::AbstractImporter::doMaterialForName(const std::string& name) virtual private

Implementation for materialForName()

Default implementation returns -1.

std::string Magnum::Trade::AbstractImporter::doMaterialName(UnsignedInt id) virtual private

Implementation for materialName()

Default implementation returns empty string.

UnsignedInt Magnum::Trade::AbstractImporter::doTextureCount() const virtual private

Implementation for textureCount()

Default implementation returns 0.

Int Magnum::Trade::AbstractImporter::doTextureForName(const std::string& name) virtual private

Implementation for textureForName()

Default implementation returns -1.

std::string Magnum::Trade::AbstractImporter::doTextureName(UnsignedInt id) virtual private

Implementation for textureName()

Default implementation returns empty string.

UnsignedInt Magnum::Trade::AbstractImporter::doImage1DCount() const virtual private

Implementation for image1DCount()

Default implementation returns 0.

Int Magnum::Trade::AbstractImporter::doImage1DForName(const std::string& name) virtual private

Implementation for image1DForName()

Default implementation returns -1.

std::string Magnum::Trade::AbstractImporter::doImage1DName(UnsignedInt id) virtual private

Implementation for image1DName()

Default implementation returns empty string.

UnsignedInt Magnum::Trade::AbstractImporter::doImage2DCount() const virtual private

Implementation for image2DCount()

Default implementation returns 0.

Int Magnum::Trade::AbstractImporter::doImage2DForName(const std::string& name) virtual private

Implementation for image2DForName()

Default implementation returns -1.

std::string Magnum::Trade::AbstractImporter::doImage2DName(UnsignedInt id) virtual private

Implementation for image2DName()

Default implementation returns empty string.

UnsignedInt Magnum::Trade::AbstractImporter::doImage3DCount() const virtual private

Implementation for image3DCount()

Default implementation returns 0.

Int Magnum::Trade::AbstractImporter::doImage3DForName(const std::string& name) virtual private

Implementation for image3DForName()

Default implementation returns -1.

std::string Magnum::Trade::AbstractImporter::doImage3DName(UnsignedInt id) virtual private

Implementation for image3DName()

Default implementation returns empty string.

Debug& operator<<(Debug& debug, AbstractImporter::Feature value)

Debug output operator.

Debug& operator<<(Debug& debug, AbstractImporter::Features value)

Debug output operator.

Magnum::Trade::AbstractImporter class #include <Magnum/Trade/AbstractImporter.h>

Contents

Enum documentation

enum class Magnum::Trade::AbstractImporter::Feature: UnsignedByte

Typedef documentation

typedef Containers::EnumSet<Feature> Magnum::Trade::AbstractImporter::Features

Function documentation

static std::string Magnum::Trade::AbstractImporter::pluginInterface()

static std::vector<std::string> Magnum::Trade::AbstractImporter::pluginSearchPaths()

auto Magnum::Trade::AbstractImporter::fileCallback()

void* Magnum::Trade::AbstractImporter::fileCallbackUserData() const

void Magnum::Trade::AbstractImporter::setFileCallback(Containers::Optional<Containers::ArrayView<const char>>(*)(const std::string&, InputFileCallbackPolicy, void*) callback, void* userData = nullptr)

template<class T> void Magnum::Trade::AbstractImporter::setFileCallback(Containers::Optional<Containers::ArrayView<const char>>(*)(const std::string&, InputFileCallbackPolicy, T&) callback, T& userData)

bool Magnum::Trade::AbstractImporter::openData(Containers::ArrayView<const char> data)

bool Magnum::Trade::AbstractImporter::openState(const void* state, const std::string& filePath = {})

bool Magnum::Trade::AbstractImporter::openFile(const std::string& filename)

void Magnum::Trade::AbstractImporter::close()

Int Magnum::Trade::AbstractImporter::defaultScene()

UnsignedInt Magnum::Trade::AbstractImporter::sceneCount() const

Int Magnum::Trade::AbstractImporter::sceneForName(const std::string& name)

std::string Magnum::Trade::AbstractImporter::sceneName(UnsignedInt id)

Containers::Optional<SceneData> Magnum::Trade::AbstractImporter::scene(UnsignedInt id)

UnsignedInt Magnum::Trade::AbstractImporter::animationCount() const

Int Magnum::Trade::AbstractImporter::animationForName(const std::string& name)

std::string Magnum::Trade::AbstractImporter::animationName(UnsignedInt id)

Containers::Optional<AnimationData> Magnum::Trade::AbstractImporter::animation(UnsignedInt id)

UnsignedInt Magnum::Trade::AbstractImporter::lightCount() const

Int Magnum::Trade::AbstractImporter::lightForName(const std::string& name)

std::string Magnum::Trade::AbstractImporter::lightName(UnsignedInt id)

Containers::Optional<LightData> Magnum::Trade::AbstractImporter::light(UnsignedInt id)

UnsignedInt Magnum::Trade::AbstractImporter::cameraCount() const

Int Magnum::Trade::AbstractImporter::cameraForName(const std::string& name)

std::string Magnum::Trade::AbstractImporter::cameraName(UnsignedInt id)

Containers::Optional<CameraData> Magnum::Trade::AbstractImporter::camera(UnsignedInt id)

UnsignedInt Magnum::Trade::AbstractImporter::object2DCount() const

Int Magnum::Trade::AbstractImporter::object2DForName(const std::string& name)

std::string Magnum::Trade::AbstractImporter::object2DName(UnsignedInt id)

Containers::Pointer<ObjectData2D> Magnum::Trade::AbstractImporter::object2D(UnsignedInt id)

UnsignedInt Magnum::Trade::AbstractImporter::object3DCount() const

Int Magnum::Trade::AbstractImporter::object3DForName(const std::string& name)

std::string Magnum::Trade::AbstractImporter::object3DName(UnsignedInt id)

Containers::Pointer<ObjectData3D> Magnum::Trade::AbstractImporter::object3D(UnsignedInt id)

UnsignedInt Magnum::Trade::AbstractImporter::mesh2DCount() const

Int Magnum::Trade::AbstractImporter::mesh2DForName(const std::string& name)

std::string Magnum::Trade::AbstractImporter::mesh2DName(UnsignedInt id)

Containers::Optional<MeshData2D> Magnum::Trade::AbstractImporter::mesh2D(UnsignedInt id)

Int Magnum::Trade::AbstractImporter::mesh3DForName(const std::string& name)

std::string Magnum::Trade::AbstractImporter::mesh3DName(UnsignedInt id)

Containers::Optional<MeshData3D> Magnum::Trade::AbstractImporter::mesh3D(UnsignedInt id)

UnsignedInt Magnum::Trade::AbstractImporter::materialCount() const

Int Magnum::Trade::AbstractImporter::materialForName(const std::string& name)

std::string Magnum::Trade::AbstractImporter::materialName(UnsignedInt id)

Containers::Pointer<AbstractMaterialData> Magnum::Trade::AbstractImporter::material(UnsignedInt id)

UnsignedInt Magnum::Trade::AbstractImporter::textureCount() const

Int Magnum::Trade::AbstractImporter::textureForName(const std::string& name)

std::string Magnum::Trade::AbstractImporter::textureName(UnsignedInt id)

Containers::Optional<TextureData> Magnum::Trade::AbstractImporter::texture(UnsignedInt id)

UnsignedInt Magnum::Trade::AbstractImporter::image1DCount() const

Int Magnum::Trade::AbstractImporter::image1DForName(const std::string& name)

std::string Magnum::Trade::AbstractImporter::image1DName(UnsignedInt id)

Containers::Optional<ImageData1D> Magnum::Trade::AbstractImporter::image1D(UnsignedInt id)

UnsignedInt Magnum::Trade::AbstractImporter::image2DCount() const

Int Magnum::Trade::AbstractImporter::image2DForName(const std::string& name)

std::string Magnum::Trade::AbstractImporter::image2DName(UnsignedInt id)

Containers::Optional<ImageData2D> Magnum::Trade::AbstractImporter::image2D(UnsignedInt id)

UnsignedInt Magnum::Trade::AbstractImporter::image3DCount() const

Int Magnum::Trade::AbstractImporter::image3DForName(const std::string& name)

std::string Magnum::Trade::AbstractImporter::image3DName(UnsignedInt id)

Containers::Optional<ImageData3D> Magnum::Trade::AbstractImporter::image3D(UnsignedInt id)

const void* Magnum::Trade::AbstractImporter::importerState() const

void Magnum::Trade::AbstractImporter::doOpenFile(const std::string& filename) virtual protected

void Magnum::Trade::AbstractImporter::doSetFileCallback(Containers::Optional<Containers::ArrayView<const char>>(*)(const std::string&, InputFileCallbackPolicy, void*) callback, void* userData) virtual private

Int Magnum::Trade::AbstractImporter::doDefaultScene() virtual private

UnsignedInt Magnum::Trade::AbstractImporter::doSceneCount() const virtual private

Int Magnum::Trade::AbstractImporter::doSceneForName(const std::string& name) virtual private

std::string Magnum::Trade::AbstractImporter::doSceneName(UnsignedInt id) virtual private

UnsignedInt Magnum::Trade::AbstractImporter::doAnimationCount() const virtual private

Int Magnum::Trade::AbstractImporter::doAnimationForName(const std::string& name) virtual private

std::string Magnum::Trade::AbstractImporter::doAnimationName(UnsignedInt id) virtual private

UnsignedInt Magnum::Trade::AbstractImporter::doLightCount() const virtual private

Magnum::Trade::AbstractImporter class
#include <Magnum/Trade/AbstractImporter.h>

void Magnum::Trade::AbstractImporter::setFileCallback(Containers::Optional<Containers::ArrayView<const char>>()(const std::string&, InputFileCallbackPolicy, void) callback, void* userData = nullptr)

template<class T>
void Magnum::Trade::AbstractImporter::setFileCallback(Containers::Optional<Containers::ArrayView<const char>>(*)(const std::string&, InputFileCallbackPolicy, T&) callback, T& userData)

void Magnum::Trade::AbstractImporter::doSetFileCallback(Containers::Optional<Containers::ArrayView<const char>>()(const std::string&, InputFileCallbackPolicy, void) callback, void* userData) virtual private