Magnum::Trade namespace

Convert a 1D image with AbstractImageConverter::convert(const ImageView1D&)

Convert a 2D image with AbstractImageConverter::convert(const ImageView2D&)

Convert a 2D image with AbstractImageConverter::convert(const ImageView2D&)

Convert a 2D image with AbstractImageConverter::convert(const ImageView2D&)

Convert a 3D image with AbstractImageConverter::convert(const ImageView3D&)

Convert a compressed 1D image with AbstractImageConverter::convert(const CompressedImageView1D&)

Convert a compressed 2D image with AbstractImageConverter::convert(const CompressedImageView2D&)

Convert a compressed 3D image with AbstractImageConverter::convert(const CompressedImageView3D&)

Convert a 1D image to a file with AbstractImageConverter::convertToFile(const ImageView1D&, Containers::StringView)

Convert a 2D image to a file with AbstractImageConverter::convertToFile(const ImageView2D&, Containers::StringView)

Convert a 2D image to a file with AbstractImageConverter::convertToFile(const ImageView2D&, Containers::StringView)

Convert a 3D image to a file with AbstractImageConverter::convertToFile(const ImageView3D&, Containers::StringView)

Convert a compressed 1D image to a file with AbstractImageConverter::convertToFile(const CompressedImageView1D&, Containers::StringView)

Convert a compressed 2D image to a file with AbstractImageConverter::convertToFile(const CompressedImageView2D&, Containers::StringView)

Convert a compressed 2D image to a file with AbstractImageConverter::convertToFile(const CompressedImageView2D&, Containers::StringView)

Convert a compressed 3D image to a file with AbstractImageConverter::convertToFile(const CompressedImageView3D&, Containers::StringView)

Convert a 1D image to raw data with AbstractImageConverter::convertToData(const ImageView1D&). Implies ImageConverterFeature::Convert1DToFile.

Convert a 2D image to raw data with AbstractImageConverter::convertToData(const ImageView2D&). Implies ImageConverterFeature::Convert2DToFile.

Convert a 2D image to raw data with AbstractImageConverter::convertToData(const ImageView2D&). Implies ImageConverterFeature::Convert2DToFile.

Convert a 3D image to raw data with AbstractImageConverter::convertToData(const ImageView3D&). Implies ImageConverterFeature::Convert3DToFile.

Convert a compressed 1D image to raw data with AbstractImageConverter::convertToData(const CompressedImageView1D&). Implies ImageConverterFeature::ConvertCompressed1DToFile.

Convert a compressed 2D image to raw data with AbstractImageConverter::convertToData(const CompressedImageView2D&). Implies ImageConverterFeature::ConvertCompressed2DToFile.

Convert a compressed 2D image to raw data with AbstractImageConverter::convertToData(const CompressedImageView2D&). Implies ImageConverterFeature::ConvertCompressed2DToFile.

Convert a compressed 3D image to raw data with AbstractImageConverter::convertToData(const CompressedImageView3D&). Implies ImageConverterFeature::ConvertCompressed3DToFile.

Convert multiple image levels with AbstractImageConverter::convertToFile(Containers::ArrayView<const ImageView1D>, Containers::StringView) / AbstractImageConverter::convertToFile(Containers::ArrayView<const CompressedImageView1D>, Containers::StringView) if ImageConverterFeature::Convert1DToFile / ConvertCompressed1DToFile is also supported; with AbstractImageConverter::convertToFile(Containers::ArrayView<const ImageView2D>, Containers::StringView) / AbstractImageConverter::convertToFile(Containers::ArrayView<const CompressedImageView2D>, Containers::StringView) if ImageConverterFeature::Convert2DToFile / ConvertCompressed2DToFile is also supported; with AbstractImageConverter::convertToFile(Containers::ArrayView<const ImageView3D>, Containers::StringView) / AbstractImageConverter::convertToFile(Containers::ArrayView<const CompressedImageView3D>, Containers::StringView) if ImageConverterFeature::Convert3DToFile / ConvertCompressed3DToFile is also supported; with AbstractImageConverter::convertToData(Containers::ArrayView<const ImageView1D>) / AbstractImageConverter::convertToData(Containers::ArrayView<const CompressedImageView1D>) if ImageConverterFeature::Convert1DToData / ConvertCompressed1DToData is also supported; with AbstractImageConverter::convertToData(Containers::ArrayView<const ImageView2D>) / AbstractImageConverter::convertToData(Containers::ArrayView<const CompressedImageView2D>) if ImageConverterFeature::Convert2DToData / ConvertCompressed2DToData is also supported; with AbstractImageConverter::convertToData(Containers::ArrayView<const ImageView3D>) / AbstractImageConverter::convertToData(Containers::ArrayView<const CompressedImageView3D>) if ImageConverterFeature::Convert3DToData / ConvertCompressed3DToData is also supported.

Print verbose diagnostic during conversion. By default the converter only prints messages on error or when some operation might cause unexpected data modification or loss.

Corresponds to the -v / --verbose option in magnum-imageconverter.

Opening files from raw data or non-temporary memory using AbstractImporter::openData() or openMemory()

Opening already loaded state using AbstractImporter::openState()

Specifying callbacks for loading additional files referenced from the main file using AbstractImporter::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.

Print verbose diagnostic during import. By default the importer only prints messages on error or when some operation might cause unexpected data modification or loss.

Corresponds to the -v / --verbose option in magnum-imageconverter, magnum-sceneconverter and magnum-player.

Convert a single mesh instance with AbstractSceneConverter::convert(const MeshData&). The function can be also used if both SceneConverterFeature::ConvertMultiple and SceneConverterFeature::AddMeshes are supported.

Convert a single mesh instance in-place with AbstractSceneConverter::convertInPlace(MeshData&).

Convert a single mesh instance to a file with AbstractSceneConverter::convertToFile(const MeshData&, Containers::StringView). The function can be also used if both SceneConverterFeature::ConvertMultipleToFile and SceneConverterFeature::AddMeshes are supported.

Convert a single mesh instance to raw data with AbstractSceneConverter::convertToData(const MeshData&). Implies SceneConverterFeature::ConvertMeshToFile. The function can be also used if both SceneConverterFeature::ConvertMultipleToData and SceneConverterFeature::AddMeshes are supported.

Convert multiple data with AbstractSceneConverter::begin() and end().

Convert multiple data to a file with AbstractSceneConverter::beginFile() and endFile(). The functions can be also used if SceneConverterFeature::ConvertMeshToFile is supported.

Convert multiple data to raw data with AbstractSceneConverter::beginData() and endData(). Implies SceneConverterFeature::ConvertMultipleToFile. The functions can be also used if SceneConverterFeature::ConvertMeshToData is supported.

Add scene instances with AbstractSceneConverter::add(const SceneData&, Containers::StringView), together with setSceneFieldName(), setObjectName() and setDefaultScene().

Add animation instances with AbstractSceneConverter::add(const AnimationData&, Containers::StringView).

Add light instances with AbstractSceneConverter::add(const LightData&, Containers::StringView).

Add camera instances with AbstractSceneConverter::add(const CameraData&, Containers::StringView).

Add 2D skin instances with AbstractSceneConverter::add(const SkinData2D&, Containers::StringView).

Add 3D skin instances with AbstractSceneConverter::add(const SkinData3D&, Containers::StringView).

Add single-level mesh instances with AbstractSceneConverter::add(const MeshData&, Containers::StringView), together with setMeshAttributeName(). This function can be also used if SceneConverterFeature::ConvertMesh, SceneConverterFeature::ConvertMeshToFile or SceneConverterFeature::ConvertMeshToData is supported.

Add material instances with AbstractSceneConverter::add(const MaterialData&, Containers::StringView).

Add texture instances with AbstractSceneConverter::add(const TextureData&, Containers::StringView).

Add single-level 1D image instances with AbstractSceneConverter::add(const ImageData1D&, Containers::StringView) or AbstractSceneConverter::add(const ImageView1D&, Containers::StringView).

Add single-level 2D image instances with AbstractSceneConverter::add(const ImageData2D&, Containers::StringView) or AbstractSceneConverter::add(const ImageView2D&, Containers::StringView).

Add single-level 3D image instances with AbstractSceneConverter::add(const ImageData3D&, Containers::StringView) or AbstractSceneConverter::add(const ImageView3D&, Containers::StringView).

Add single-level compressed 1D image instances with AbstractSceneConverter::add(const ImageData1D&, Containers::StringView) or AbstractSceneConverter::add(const CompressedImageView1D&, Containers::StringView).

Add single-level compressed 2D image instances with AbstractSceneConverter::add(const ImageData2D&, Containers::StringView) or AbstractSceneConverter::add(const CompressedImageView2D&, Containers::StringView).

Add single-level compressed 3D image instances with AbstractSceneConverter::add(const ImageData3D&, Containers::StringView) or AbstractSceneConverter::add(const CompressedImageView3D&, Containers::StringView).

Add multiple mesh levels with AbstractSceneConverter::add(Containers::Iterable<const MeshData>, Containers::StringView) if SceneConverterFeature::AddMeshes is also supported.

Add multiple image levels with AbstractSceneConverter::add(Containers::Iterable<const ImageData1D>, Containers::StringView) if SceneConverterFeature::AddImages1D or AddCompressedImages1D is also supported; with AbstractSceneConverter::add(Containers::Iterable<const ImageData2D>, Containers::StringView) if SceneConverterFeature::AddImages2D or AddCompressedImages2D is also supported; or with AbstractSceneConverter::add(Containers::Iterable<const ImageData1D>, Containers::StringView) if SceneConverterFeature::AddImages3D or AddCompressedImages3D is also supported.

Print verbose diagnostic during conversion. By default the converter only prints messages on error or when some operation might cause unexpected data modification or loss.

Corresponds to the -v / --verbose option in magnum-sceneconverter.

Scenes. Passes SceneData from AbstractImporter::scene() to AbstractSceneConverter::add(const SceneData&, Containers::StringView); AbstractImporter::defaultScene() to AbstractSceneConverter::setDefaultScene(); and for all custom fields, AbstractImporter::sceneFieldName() to AbstractSceneConverter::setSceneFieldName().

Animations. Passes AnimationData from AbstractImporter::animation() to AbstractSceneConverter::add(const AnimationData&, Containers::StringView)

Lights. Passes LightData from AbstractImporter::light() to AbstractSceneConverter::add(const LightData&, Containers::StringView).

Cameras. Passes SceneData from AbstractImporter::camera() to AbstractSceneConverter::add(const CameraData&, Containers::StringView).

2D skins. Passes SkinData2D from AbstractImporter::skin2D() to AbstractSceneConverter::add(const SkinData2D&, Containers::StringView).

3D skins. Passes SkinData3D from AbstractImporter::skin2D() to AbstractSceneConverter::add(const SkinData3D&, Containers::StringView).

Meshes. Passes MeshData from AbstractImporter::mesh(), to AbstractSceneConverter::add(const MeshData&, Containers::StringView); and for all custom attributes, AbstractImporter::meshAttributeName() to AbstractSceneConverter::setMeshAttributeName().

Materials. Passes MaterialData from AbstractImporter::material() to AbstractSceneConverter::add(const MaterialData&, Containers::StringView).

Textures. Passes TextureData from AbstractImporter::texture() to AbstractSceneConverter::add(const TextureData&, Containers::StringView).

1D images. Passes ImageData1D from AbstractImporter::image1D() to AbstractSceneConverter::add(const ImageData1D&, Containers::StringView). If the image is compressed and only SceneConverterFeature::AddImages1D is supported or the image is uncompressed and only SceneConverterFeature::AddCompressedImages1D is supported, results in an error.

2D images. Passes ImageData2D from AbstractImporter::image2D() to AbstractSceneConverter::add(const ImageData2D&, Containers::StringView). If the image is compressed and only SceneConverterFeature::AddImages2D is supported or the image is uncompressed and only SceneConverterFeature::AddCompressedImages2D is supported, results in an error.

3D images. Passes ImageData3D from AbstractImporter::image3D() to AbstractSceneConverter::add(const ImageData3D&, Containers::StringView). If the image is compressed and only SceneConverterFeature::AddImages3D is supported or the image is uncompressed and only SceneConverterFeature::AddCompressedImages3D is supported, results in an error.

Multiple mesh levels. For every mesh gathers MeshData from all AbstractImporter::meshLevelCount() and passes them to AbstractSceneConverter::add(Containers::Iterable<const MeshData>, Containers::StringView) instead of passing just the first level to AbstractSceneConverter::add(const MeshData&, Containers::StringView).

Multiple image levels. For every image gathers ImageData1D / ImageData2D / ImageData3D from all AbstractImporter::image1DLevelCount() / image2DLevelCount() / image3DLevelCount() and passes them to AbstractSceneConverter::add(Containers::Iterable<const ImageData1D>, Containers::StringView) / add(Containers::Iterable<const ImageData2D>, Containers::StringView) / add(Containers::Iterable<const ImageData3D>, Containers::StringView) instead of just passing the first level to

AbstractSceneConverter::add(const ImageData1D&, Containers::StringView) / add(const ImageData2D&, Containers::StringView) / add(const ImageData2D&, Containers::StringView).

Data names. For every supported data queries also AbstractImporter::sceneName(), objectName(), animationName(), lightName(), cameraName(), skin2DName(), skin3DName(), meshName(), materialName(), textureName(), image1DName(), image2DName() or image3DName() and passes them to the converter. AbstractImporter::sceneFieldName() and meshAttributeName() are however passed always to avoid information loss.

bool

Float

UnsignedInt

Int

BitVector2

BitVector2

BitVector3

BitVector3

BitVector4

BitVector4

Vector2. Usually used for AnimationTrackTargetType::Translation2D and AnimationTrackTargetType::Scaling2D.

Vector2ui

Vector2i

Vector3. Usually used for AnimationTrackTargetType::Translation3D and AnimationTrackTargetType::Scaling3D.

Vector3ui

Vector3i

Vector4

Vector4ui

Vector4i

Complex. Usually used for AnimationTrackTargetType::Rotation2D.

Quaternion. Usually used for AnimationTrackTargetType::Rotation3D.

DualQuaternion

CubicHermite1D

CubicHermite2D. Usually used for spline-interpolated AnimationTrackTargetType::Translation2D and AnimationTrackTargetType::Scaling2D.

CubicHermite3D. Usually used for spline-interpolated AnimationTrackTargetType::Translation3D and AnimationTrackTargetType::Scaling3D.

CubicHermiteComplex. Usually used for spline-interpolated AnimationTrackTargetType::Rotation2D.

CubicHermiteQuaternion. Usually used for spline-interpolated AnimationTrackTargetType::Rotation3D.

Modifies 2D object translation. Type is usually Vector2 or CubicHermite2D for spline-interpolated data.

Modifies 3D object translation. Type is usually Vector3 or CubicHermite3D for spline-interpolated data.

Modifies 2D object rotation. Type is usually Complex or CubicHermiteComplex for spline-interpolated data.

Modifies 3D object rotation. Type is usually Quaternion or CubicHermiteQuaternion for spline-interpolated data.

Modifies 2D object scaling. Type is usually Vector2 or CubicHermite2D for spline-interpolated data.

Modifies 3D object scaling. Type is usually Vector3 or CubicHermite3D for spline-interpolated data.

This and all higher values are for importer-specific targets. Can be of any type, AnimationData::trackTarget() might or might not point to an existing object. See documentation of a particular importer for details.

2D orthographic camera

3D orthographic camera

3D perspective camera

Data is owned by the instance, meaning it stays in scope for as long as the instance. If neither this flag nor DataFlag::ExternallyOwned is set, the data is considered to be just a temporary allocation and no assumptions about its lifetime can be made.

Data has an owner external to the instance, for example a memory-mapped file or a constant memory. In general the data lifetime exceeds lifetime of the instance wrapping it. If neither this flag nor DataFlag::ExternallyOwned is set, the data is considered to be just a temporary allocation and no assumptions about its lifetime can be made.

Data is mutable. If this flag is not set, the instance might be for example referencing a readonly memory-mapped file or a constant memory.

Clear coat material layer.

Expected to contain (a subset of) the MaterialAttribute::Roughness, MaterialAttribute::RoughnessTexture, MaterialAttribute::RoughnessTextureSwizzle, MaterialAttribute::RoughnessTextureMatrix, MaterialAttribute::RoughnessTextureCoordinates, MaterialAttribute::NormalTexture, MaterialAttribute::NormalTextureSwizzle, MaterialAttribute::NormalTextureMatrix and MaterialAttribute::NormalTextureCoordinates attributes.

Layer name, MaterialAttributeType::String.

Unlike other attributes where string name matches the enum name, in this case the corresponding string is " LayerName" (with a space at the front), done in order to have the layer name attribute appear first in each layer and thus simplify layer implementation.

Alpha mask, MaterialAttributeType::Float.

If set together with MaterialAttribute::AlphaBlend, blending is preferred, however renderers can fall back to alpha-masked rendering. Alpha values below this value are meant to be rendered as fully transparent and alpha values above this value as fully opaque.

Alpha blending, MaterialAttributeType::Bool.

If true, the material is expected to be rendered with blending enabled and in correct depth order. If false or not present, the material should be treated as opaque. If set together with MaterialAttribute::AlphaMask, blending is preferred, however renderers can fall back to alpha-masked rendering.

Double sided, MaterialAttributeType::Bool.

If not present, the default value is false.

Ambient color for Phong materials, MaterialAttributeType::Vector4.

If MaterialAttribute::AmbientTexture is present as well, these two are multiplied together.

Ambient texture index for Phong materials, MaterialAttributeType::UnsignedInt.

If MaterialAttribute::AmbientColor is present as well, these two are multiplied together.

Ambient texture transformation matrix for Phong materials, MaterialAttributeType::Matrix3x3.

Has a precedence over MaterialAttribute::TextureMatrix if both are present.

Ambient texture coordinate set index for Phong materials, MaterialAttributeType::UnsignedInt.

Has a precedence over MaterialAttribute::TextureCoordinates if both are present.

Ambient texture array layer for Phong materials, MaterialAttributeType::UnsignedInt.

Has a precedence over MaterialAttribute::TextureLayer if both are present.

Diffuse color for Phong or PBR specular/glossiness materials, MaterialAttributeType::Vector4.

If MaterialAttribute::DiffuseTexture is present as well, these two are multiplied together.

Diffuse texture index for Phong or PBR specular/glossiness materials, MaterialAttributeType::UnsignedInt.

If MaterialAttribute::DiffuseColor is present as well, these two are multiplied together.

Diffuse texture transformation matrix for Phong or PBR specular/glossiness materials, MaterialAttributeType::Matrix3x3.

Has a precedence over MaterialAttribute::TextureMatrix if both are present.

Diffuse texture coordinate set index for Phong or PBR specular/glossiness materials, MaterialAttributeType::UnsignedInt.

Has a precedence over MaterialAttribute::TextureCoordinates if both are present.

Diffuse texture array layer for Phong materials, MaterialAttributeType::UnsignedInt.

Has a precedence over MaterialAttribute::TextureLayer if both are present.

Specular color for Phong or PBR specular/glossiness materials, MaterialAttributeType::Vector4. Alpha is commonly zero to not interfere with alpha-masked objects, non-zero alpha can be for example used to render transparent material which are still expected to have specular highlights such as glass or soap bubbles.

If MaterialAttribute::SpecularTexture or MaterialAttribute::SpecularGlossinessTexture is present as well, these two are multiplied together.

Specular texture index for Phong or PBR specular/glossiness materials, MaterialAttributeType::UnsignedInt.

If MaterialAttribute::SpecularColor is present as well, these two are multiplied together. Can be alternatively supplied as a packed MaterialAttribute::SpecularGlossinessTexture.

Specular texture swizzle for Phong or PBR specular/glossiness materials, MaterialAttributeType::TextureSwizzle.

Can be used to describe whether the alpha channel of a MaterialAttribute::SpecularTexture is used or not. Either MaterialTextureSwizzle::RGBA or MaterialTextureSwizzle::RGB (which is the default) is expected. Does not apply to MaterialAttribute::SpecularGlossinessTexture — in that case, the specular texture is always three-channel, regardless of this attribute.

Specular texture transformation matrix for Phong or PBR specular/glossiness materials, MaterialAttributeType::Matrix3x3.

Has a precedence over MaterialAttribute::TextureMatrix if both are present.

Specular texture coordinate set index for Phong or PBR specular/glossiness materials, MaterialAttributeType::UnsignedInt.

Has a precedence over MaterialAttribute::TextureCoordinates if both are present.

Specular texture array layer for Phong materials, MaterialAttributeType::UnsignedInt.

Has a precedence over MaterialAttribute::TextureLayer if both are present.

Shininess value for Phong materials, MaterialAttributeType::Float.

Base color for PBR metallic/roughness materials, MaterialAttributeType::Vector4.

If MaterialAttribute::BaseColorTexture is present as well, these two are multiplied together.

Base color texture index for PBR metallic/roughness materials, MaterialAttributeType::UnsignedInt.

If MaterialAttribute::BaseColor is present as well, these two are multiplied together.

Base color texture transformation matrix for PBR metallic/roughness materials, MaterialAttributeType::Matrix3x3.

Has a precedence over MaterialAttribute::TextureMatrix if both are present.

Base color texture coordinate set index for PBR metallic/roughness materials, MaterialAttributeType::UnsignedInt.

Has a precedence over MaterialAttribute::TextureCoordinates if both are present.

Base color texture array layer for PBR metallic/roughness materials, MaterialAttributeType::UnsignedInt.

Has a precedence over MaterialAttribute::TextureLayer if both are present.

Metalness for PBR metallic/roughness materials, MaterialAttributeType::Float.

If MaterialAttribute::MetalnessTexture or MaterialAttribute::NoneRoughnessMetallicTexture is present as well, these two are multiplied together.

Metalness texture index for PBR metallic/roughness materials, MaterialAttributeType::UnsignedInt.

If MaterialAttribute::Metalness is present as well, these two are multiplied together. Can be alternatively supplied as a packed MaterialAttribute::NoneRoughnessMetallicTexture.

Metalness texture swizzle for PBR metallic/roughness materials, MaterialAttributeType::TextureSwizzle.

Can be used to express arbitrary packing of MaterialAttribute::MetalnessTexture together with other maps in a single texture. A single-channel swizzle value is expected. If not present, MaterialTextureSwizzle::R is assumed. Does not apply to MaterialAttribute::NoneRoughnessMetallicTexture — in that case, the metalness is implicitly in the red channel regardless of this attribute.

Metalness texture transformation matrix for PBR metallic/roughness materials, MaterialAttributeType::Matrix3x3.

Has a precedence over MaterialAttribute::TextureMatrix if both are present.

Metalness texture coordinate set index for PBR metallic/roughness materials, MaterialAttributeType::UnsignedInt.

Has a precedence over MaterialAttribute::TextureCoordinates if both are present.

Metalness texture array layer for PBR metallic/roughness materials, MaterialAttributeType::UnsignedInt.

Has a precedence over MaterialAttribute::TextureLayer if both are present.

Roughness for PBR metallic/roughness materials, MaterialAttributeType::Float.

If MaterialAttribute::RoughnessTexture or MaterialAttribute::NoneRoughnessMetallicTexture is present as well, these two are multiplied together.

Roughness texture index for PBR metallic/roughness materials, MaterialAttributeType::UnsignedInt.

If MaterialAttribute::Roughness is present as well, these two are multiplied together. Can be alternatively supplied as a packed MaterialAttribute::NoneRoughnessMetallicTexture.

Roughness texture swizzle for PBR metallic/roughness materials, MaterialAttributeType::TextureSwizzle.

Can be used to express arbitrary packing of MaterialAttribute::RoughnessTexture together with other maps in a single texture. A single-channel swizzle value is expected. If not present, MaterialTextureSwizzle::R is assumed. Does not apply to MaterialAttribute::NoneRoughnessMetallicTexture — in that case, the metalness is implicitly in the green channel regardless of this attribute.

Roughness texture transformation matrix for PBR metallic/roughness materials, MaterialAttributeType::Matrix3x3.

Has a precedence over MaterialAttribute::TextureMatrix if both are present.

Roughness texture coordinate set index for PBR metallic/roughness materials, MaterialAttributeType::UnsignedInt.

Has a precedence over MaterialAttribute::TextureCoordinates if both are present.

Roughness texture array layer for PBR metallic/roughness materials, MaterialAttributeType::UnsignedInt.

Has a precedence over MaterialAttribute::TextureLayer if both are present.

Combined roughness/metallic texture index for PBR metallic/roughness materials with metalness in the blue channel and roughness in the green channel, MaterialAttributeType::UnsignedInt.

If MaterialAttribute::Metalness / MaterialAttribute::Roughness is present as well, these two are multiplied together.

This is a convenience alias to simplify representation of glTF and UE4 materials, which is where this packing is used (rationale). This packing (and other variants) can be alternatively specified as a pair of MaterialAttribute::RoughnessTexture / MaterialAttribute::MetalnessTexture attributes together with MaterialAttribute::RoughnessTextureSwizzle set to MaterialTextureSwizzle::G and MaterialAttribute::MetalnessTextureSwizzle set to MaterialTextureSwizzle::B. Texture transformation and coordinate set, if needed, have to be specified either using the global MaterialAttribute::TextureMatrix and MaterialAttribute::TextureCoordinates attributes or the per-texture MaterialAttribute::RoughnessTextureMatrix, MaterialAttribute::MetalnessTextureMatrix, MaterialAttribute::RoughnessTextureCoordinates and MaterialAttribute::MetalnessTextureCoordinates variants.

Glossiness for PBR specular/glossiness materials, MaterialAttributeType::Float.

If MaterialAttribute::GlossinessTexture or MaterialAttribute::SpecularGlossinessTexture is present as well, these two are multiplied together.

Glossiness texture index for PBR specular/glossiness materials, MaterialAttributeType::UnsignedInt.

If MaterialAttribute::Glossiness is present as well, these two are multiplied together. Can be alternatively supplied as a packed MaterialAttribute::SpecularGlossinessTexture.

Glossiness texture swizzle for PBR specular/glossiness materials, MaterialAttributeType::TextureSwizzle.

Can be used to express arbitrary packing of MaterialAttribute::GlossinessTexture together with other maps in a single texture. A single-channel swizzle value is expected. If not present, MaterialTextureSwizzle::R is assumed. Does not apply to MaterialAttribute::SpecularGlossinessTexture — in that case, the glossiness is implicitly in the alpha channel regardless of this attribute.

Glossiness texture transformation matrix for PBR specular/glossiness materials, MaterialAttributeType::Matrix3x3.

Has a precedence over MaterialAttribute::TextureMatrix if both are present.

Glossiness texture coordinate set index for PBR specular/glossiness materials, MaterialAttributeType::UnsignedInt.

Has a precedence over MaterialAttribute::TextureCoordinates if both are present.

Metalness texture array layer for PBR specular/glossiness materials, MaterialAttributeType::UnsignedInt.

Has a precedence over MaterialAttribute::TextureLayer if both are present.

Combined specular/glossiness texture index for PBR specular/glossiness materials with specular color in the RGB channels and glossiness in alpha, MaterialAttributeType::UnsignedInt.

If MaterialAttribute::SpecularColor / MaterialAttribute::Glossiness is present as well, these two are multiplied together. Can be alternatively specified as a pair of MaterialAttribute::SpecularTexture / MaterialAttribute::GlossinessTexture attributes together with MaterialAttribute::GlossinessTextureSwizzle set to MaterialTextureSwizzle::A. Texture transformation and coordinate set, if needed, have to be specified either using the global MaterialAttribute::TextureMatrix and MaterialAttribute::TextureCoordinates attributes or the per-texture MaterialAttribute::SpecularTextureMatrix, MaterialAttribute::GlossinessTextureMatrix, MaterialAttribute::SpecularTextureCoordinates and MaterialAttribute::GlossinessTextureCoordinates variants.

Tangent-space normal map texture index, MaterialAttributeType::UnsignedInt.

If MaterialAttribute::NormalTextureScale is present as well, these two are multiplied together, affecting strength of the effect. The scale multiplies the XY channels of a normal fetched from (usually) an unsigned normal texture . The result is renormalized again after to form the final normal :

Normal texture scale, MaterialAttributeType::Float.

Scales the texture defined by MaterialAttribute::NormalTexture, see above for details.

Normal texture swizzle, MaterialAttributeType::TextureSwizzle.

Can be used to express arbitrary packing together with other maps in a single texture. A two- or three-channel swizzle value is expected. If not present, MaterialTextureSwizzle::RGB is assumed.

If the texture is just two-component, the remaining component is implicit and calculated as . In order to account for numeric issues and avoid negative values under the square root, it's commonly done as . Additionally, to mitigate artifacts when storing normal texture in a compressed format, MaterialTextureSwizzle::GA may get used instead of MaterialTextureSwizzle::RG.

Shader code that is able to reconstruct a XYZ normal from both RG and GA variants assuming constant values in other channels (source):

/* Assumes (1, y, 1, x) or (x, y, <anything>, 1) */
vec3 unpackTwoChannelNormal(vec4 packed) {
    packed.x *= packed.w;

    /* reconstruct Z */
    vec3 normal;
    normal.xy = packed.xy*2.0 - 1.0;
    normal.z = sqrt(max(0.0, 1.0 - dot(normal.xy,
                                       normal.xy)));
    return normal;
}

Normal texture transformation matrix, MaterialAttributeType::Matrix3x3.

Has a precedence over MaterialAttribute::TextureMatrix if both are present.

Normal texture coordinate set index, MaterialAttributeType::UnsignedInt.

Has a precedence over MaterialAttribute::TextureCoordinates if both are present.

Normal texture array layer, MaterialAttributeType::UnsignedInt.

Has a precedence over MaterialAttribute::TextureLayer if both are present.

Occlusion texture index, MaterialAttributeType::UnsignedInt.

Single-channel texture that multiplies the resulting material color :

If MaterialAttribute::OcclusionTextureStrength is present as well, it's used as an interpolation factor between material color and color with occlusion applied :

Occlusion texture strength, MaterialAttributeType::Float.

Affects the texture defined by MaterialAttribute::OcclusionTexture, see above for details.

Occlusion texture swizzle, MaterialAttributeType::TextureSwizzle.

Can be used to express arbitrary packing together with other maps in a single texture. A single-channel swizzle value is expected. If not present, MaterialTextureSwizzle::R is assumed.

Occlusion texture transformation matrix, MaterialAttributeType::Matrix3x3.

Has a precedence over MaterialAttribute::TextureMatrix if both are present.

Occlusion texture coordinate set index, MaterialAttributeType::UnsignedInt.

Has a precedence over MaterialAttribute::TextureCoordinates if both are present.

Occlusion texture array layer, MaterialAttributeType::UnsignedInt.

Has a precedence over MaterialAttribute::TextureLayer if both are present.

Emissive color, MaterialAttributeType::Vector3.

If MaterialAttribute::EmissiveTexture is present as well, these two are multiplied together.

Emissive texture index, MaterialAttributeType::UnsignedInt.

If MaterialAttribute::EmissiveColor is present as well, these two are multiplied together.

Emissive texture transformation matrix, MaterialAttributeType::Matrix3x3.

Has a precedence over MaterialAttribute::TextureMatrix if both are present.

Emissive texture coordinate set index, MaterialAttributeType::UnsignedInt.

Has a precedence over MaterialAttribute::TextureCoordinates if both are present.

Emissive texture array layer, MaterialAttributeType::UnsignedInt.

Has a precedence over MaterialAttribute::TextureLayer if both are present.

Layer intensity. MaterialAttributeType::Float.

Expected to be contained in additional layers, not the base material. The exact semantic of this attribute is layer-specific. If MaterialAttribute::LayerFactorTexture is present as well, these two are multiplied together.

Layer intensity texture, MaterialAttributeType::UnsignedInt.

Expected to be contained in additional layers, not the base material. The exact semantic of this attribute is layer-specific. If MaterialAttribute::LayerFactor is present as well, these two are multiplied together.

Layer intensity texture swizzle, MaterialAttributeType::TextureSwizzle.

Can be used to express arbitrary packing together with other maps in a single texture. A single-channel swizzle value is expected. If not present, MaterialTextureSwizzle::R is assumed.

Layer intensity texture transformation matrix, MaterialAttributeType::Matrix3x3.

Expected to be contained in additional layers, not the base material. Has a precedence over MaterialAttribute::TextureMatrix if both are present.

Layer intensity texture coordinate set index, MaterialAttributeType::UnsignedInt.

Expected to be contained in additional layers, not the base material. Has a precedence over MaterialAttribute::TextureCoordinates if both are present.

Layer intensity texture array layer, MaterialAttributeType::UnsignedInt.

Expected to be contained in additional layers, not the base material. Has a precedence over MaterialAttribute::TextureLayer if both are present.

Common texture transformation matrix for all textures, MaterialAttributeType::Matrix3x3.

MaterialAttribute::AmbientTextureMatrix / MaterialAttribute::DiffuseTextureMatrix / MaterialAttribute::SpecularTextureMatrix / MaterialAttribute::MetalnessTextureMatrix / MaterialAttribute::RoughnessTextureMatrix / MaterialAttribute::GlossinessTextureMatrix / MaterialAttribute::NormalTextureMatrix / MaterialAttribute::OcclusionTextureMatrix / MaterialAttribute::EmissiveTextureMatrix / MaterialAttribute::LayerFactorTextureMatrix have a precedence over this attribute for given texture, if present.

Common texture coordinate set index for all textures, MaterialAttributeType::UnsignedInt.

MaterialAttribute::AmbientTextureCoordinates / MaterialAttribute::DiffuseTextureCoordinates / MaterialAttribute::SpecularTextureCoordinates / MaterialAttribute::MetalnessTextureCoordinates / MaterialAttribute::RoughnessTextureCoordinates / MaterialAttribute::GlossinessTextureCoordinates / MaterialAttribute::NormalTextureCoordinates / MaterialAttribute::OcclusionTextureCoordinates / MaterialAttribute::EmissiveTextureCoordinates / MaterialAttribute::LayerFactorTextureCoordinates have a precedence over this attribute for given texture, if present.

Common texture array layer for all textures, MaterialAttributeType::UnsignedInt.

MaterialAttribute::AmbientTextureLayer / MaterialAttribute::DiffuseTextureLayer / MaterialAttribute::SpecularTextureLayer / MaterialAttribute::MetalnessTextureLayer / MaterialAttribute::RoughnessTextureLayer / MaterialAttribute::GlossinessTextureLayer / MaterialAttribute::NormalTextureLayer / MaterialAttribute::OcclusionTextureLayer / MaterialAttribute::EmissiveTextureLayer / MaterialAttribute::LayerFactorTextureLayer have a precedence over this attribute for given texture, if present.

Red component

Green component

Blue component

Alpha component

Red and green component

Green and blue component

Green and alpha component. May get used to mitigate artifacts when storing two independent channels (such as two-channel normal maps) in compressed texture formats — these commonly have separately compressed RGB and alpha, with green channel having the most precision of the RGB triplet.

Blue and alpha component

RGB components

GBA components

RGBA components

bool

Float

Deg

Rad

UnsignedInt

Int

UnsignedLong

Long

Vector2

Vector2ui

Vector2i

Vector3

Vector3ui

Vector3i

Vector4

Vector4ui

Vector4i

Matrix2x2

Matrix2x3

Matrix2x4

Matrix3x2

Matrix3x3

Matrix3x4

Matrix4x2

Matrix4x3

const void*, type is not preserved. For convenience it's possible to retrieve the value by calling attribute<const T*>() with an arbitrary T but the user has to ensure the type is correct.

void*, type is not preserved. For convenience it's possible to retrieve the value by calling attribute<T*>() with an arbitrary T but the user has to ensure the type is correct.

Null-terminated string. Can be stored using any type convertible to Containers::StringView, retrieval has to be done using Containers::StringView.

One of the values from MaterialTextureSwizzle

Flat. Use FlatMaterialData for convenience attribute access. Materials of this type are generally not combined with any other types.

Phong. Use PhongMaterialData for convenience attribute access.

PBR metallic/roughness. Use PbrMetallicRoughnessMaterialData for convenience attribute access.

PBR specular/glossiness. Use PbrSpecularGlossinessMaterialData for convenience attribute access.

PBR clear coat layer. Use PbrClearCoatMaterialData for convenience attribute access.

Alpha value is ignored and the rendered output is fully opaque.

The rendered output is either fully transparent or fully opaque, depending on the alpha value and specified MaterialData::alphaMask() value.

The alpha value is used to combine source and destination colors using additive blending.

Position. Type is usually VertexFormat::Vector2 for 2D and VertexFormat::Vector3 for 3D, but can be also any of VertexFormat::Vector2h, VertexFormat::Vector3h, VertexFormat::Vector2ub, VertexFormat::Vector2ubNormalized, VertexFormat::Vector2b, VertexFormat::Vector2bNormalized, VertexFormat::Vector2us, VertexFormat::Vector2usNormalized, VertexFormat::Vector2s, VertexFormat::Vector2sNormalized, VertexFormat::Vector3ub, VertexFormat::Vector3ubNormalized, VertexFormat::Vector3b, VertexFormat::Vector3bNormalized, VertexFormat::Vector3us, VertexFormat::Vector3usNormalized, VertexFormat::Vector3s or VertexFormat::Vector3sNormalized. Corresponds to Shaders::GenericGL::Position.

Tangent, optionally including bitangent sign. In the first case the type is usually VertexFormat::Vector3, but can be also VertexFormat::Vector3h, VertexFormat::Vector3bNormalized or VertexFormat::Vector3sNormalized; in the second case the type is VertexFormat::Vector4 (or VertexFormat::Vector4h, VertexFormat::Vector4bNormalized, VertexFormat::Vector4sNormalized) and the fourth component is a sign value (-1.0f or +1.0f) defining handedness of the tangent basis. Reconstructing the MeshAttribute::Bitangent can be then done like this:

Vector3 bitangent = Math::cross(normal, tangent.xyz())*tangent.w();

Corresponds to Shaders::GenericGL::Tangent or Shaders::GenericGL::Tangent4.

Bitangent. Type is usually VertexFormat::Vector3, but can be also VertexFormat::Vector3h, VertexFormat::Vector3bNormalized or VertexFormat::Vector3sNormalized. For better storage efficiency, the bitangent can be also reconstructed from the normal and tangent, see MeshAttribute::Tangent for more information. Corresponds to Shaders::GenericGL::Bitangent.

Normal. Type is usually VertexFormat::Vector3, but can be also VertexFormat::Vector3h. VertexFormat::Vector3bNormalized or VertexFormat::Vector3sNormalized. Corresponds to Shaders::GenericGL::Normal.

Texture coordinates. Type is usually VertexFormat::Vector2 for 2D coordinates, but can be also any of VertexFormat::Vector2h, VertexFormat::Vector2ub, VertexFormat::Vector2ubNormalized, VertexFormat::Vector2b, VertexFormat::Vector2bNormalized, VertexFormat::Vector2us, VertexFormat::Vector2usNormalized, VertexFormat::Vector2s or VertexFormat::Vector2sNormalized. Corresponds to Shaders::GenericGL::TextureCoordinates.

Vertex color. Type is usually VertexFormat::Vector3 or VertexFormat::Vector4, but can be also any of VertexFormat::Vector3h, VertexFormat::Vector4h, VertexFormat::Vector3ubNormalized, VertexFormat::Vector3usNormalized, VertexFormat::Vector4ubNormalized or VertexFormat::Vector4usNormalized. Corresponds to Shaders::GenericGL::Color3 or Shaders::GenericGL::Color4.

(Instanced) object ID for editor selection or scene annotation. Type is usually VertexFormat::UnsignedInt, but can be also VertexFormat::UnsignedShort or VertexFormat::UnsignedByte. Corresponds to Shaders::GenericGL::ObjectId.

Camera instance (see CameraData)

Mesh instance. The data can be cast to MeshObjectData2D to provide more information.

Empty

The object provides separate translation / rotation / scaling properties. The ObjectData2D::transformation() matrix returns them combined, but it's possible to access particular parts of the transformation using ObjectData2D::translation(), ObjectData2D::rotation() and ObjectData2D::scaling().

Camera instance (see CameraData)

Light instance (see LightData)

Mesh instance. The data can be cast to MeshObjectData3D to provide more information.

Empty

The object provides separate translation / rotation / scaling properties. The ObjectData3D::transformation() matrix returns them combined, but it's possible to access particular parts of the transformation using ObjectData3D::translation(), ObjectData3D::rotation() and ObjectData3D::scaling().

UnsignedByte

UnsignedShort

UnsignedInt

UnsignedLong

Parent object. Type is usually SceneFieldType::Int, but can be also any of Byte, Short or a Long. A value of -1 means there's no parent. An object should have only one parent, altough this isn't enforced in any way, and which of the duplicate fields gets used is not defined.

Transformation. Type is usually SceneFieldType::Matrix3x3 for 2D and SceneFieldType::Matrix4x4 for 3D, but can be also any of Matrix3x3d, Matrix3x2 or Matrix3x2d (with the bottom row implicitly assumed to be ), DualComplex or DualComplexd for 2D and Matrix4x4d, Matrix4x3 or Matrix4x3d (with the bottom row implicitly assumed to be ), DualQuaternion or DualQuaterniond for 3D. An object should have only one transformation, altough this isn't enforced in any way, and which of the duplicate fields gets used is not defined.

The transformation can be also represented by separate SceneField::Translation, SceneField::Rotation and SceneField::Scaling fields. All present transformation-related fields are expected to have the same dimensionality — either all 2D or all 3D. If both SceneField::Transformation and TRS fields are specified, it's expected that all objects that have TRS fields have a combined transformation field as well, and SceneData::transformations2DAsArray() / SceneData::transformations3DAsArray() then takes into account only the combined transformation field. TRS fields can however be specified only for a subset of transformed objects, useful for example when only certain objects have these properties animated.

Translation. Type is usually SceneFieldType::Vector2 for 2D and SceneFieldType::Vector3 for 3D, but can be also any of Vector2d for 2D and Vector3d for 3D. An object should have only one translation, altough this isn't enforced in any way, and which of the duplicate fields gets used is not defined.

The translation field usually is (but doesn't have to be) complemented by a SceneField::Rotation and SceneField::Scaling, which, if present, are expected to all share the same object mapping view and have the same dimensionality, either all 2D or all 3D. The TRS components can either completely replace SceneField::Transformation or be provided just for a subset of it — see its documentation for details.

Rotation. Type is usually SceneFieldType::Complex for 2D and SceneFieldType::Quaternion for 3D, but can be also any of Complexd for 2D and Quaterniond for 3D. An object should have only one rotation, altough this isn't enforced in any way, and which of the duplicate fields gets used is not defined.

The rotation field usually is (but doesn't have to be) complemented by a SceneField::Translation and SceneField::Scaling, which, if present, are expected to all share the same object mapping view and have the same dimensionality, either all 2D or all 3D. The TRS components can either completely replace SceneField::Transformation or be provided just for a subset of it — see its documentation for details.

Scaling. Type is usually SceneFieldType::Vector2 for 2D and SceneFieldType::Vector3 for 3D, but can be also any of Vector2d for 2D and Vector3d for 3D. An object should have only one scaling, altough this isn't enforced in any way, and which of the duplicate fields gets used is not defined.

The scaling field usually is (but doesn't have to be) complemented by a SceneField::Translation and SceneField::Rotation, which, if present, are expected to all share the same object mapping view and have the same dimensionality, either all 2D or all 3D. The TRS components can either completely replace SceneField::Transformation or be provided just for a subset of it — see its documentation for details.

ID of a mesh associated with this object, corresponding to the ID passed to AbstractImporter::mesh(). Type is usually SceneFieldType::UnsignedInt, but can be also any of UnsignedByte or UnsignedShort. An object can have multiple meshes associated.

Usually complemented with a SceneField::MeshMaterial, although not required. If present, both should share the same object mapping view. Objects with multiple meshes then have the Nth mesh associated with the Nth material.

ID of a material for a SceneField::Mesh, corresponding to the ID passed to AbstractImporter::material() or -1 if the mesh has no material associated. Type is usually SceneFieldType::Int, but can be also any of Byte or Short. Expected to share the object mapping view with SceneField::Mesh.

ID of a light associated with this object, corresponding to the ID passed to AbstractImporter::light(). Type is usually SceneFieldType::UnsignedInt, but can be also any of UnsignedByte or UnsignedShort. An object can have multiple lights associated.

ID of a camera associated with this object, corresponding to the ID passed to AbstractImporter::camera(). Type is usually SceneFieldType::UnsignedInt, but can be also any of UnsignedByte or UnsignedShort. An object can have multiple cameras associated.

ID of a skin associated with this object, corresponding to the ID passed to AbstractImporter::skin2D() or AbstractImporter::skin3D(), depending on whether the scene has a 2D or 3D transformation. Type is usually SceneFieldType::UnsignedInt, but can be also any of UnsignedByte or UnsignedShort. An object can have multiple skins associated.

Importer state for given object, per-object counterpart to scene-specific SceneData::importerState(). Type is usually SceneFieldType::Pointer but can be also SceneFieldType::MutablePointer. An object should have only one importer state, altough this isn't enforced in any way, and which of the duplicate fields gets used is not defined.

Float

Half

Double

UnsignedByte

Byte

UnsignedShort

Short

UnsignedInt

Int

UnsignedLong

Long

Vector2

Vector2h

Vector2d

Vector2ub

Vector2b

Vector2us

Vector2s

Vector2ui

Vector2i

Vector3

Vector3h

Vector3d

Vector3ub

Vector3b

Vector3us

Vector3s

Vector3ui

Vector3i

Vector4

Vector4h

Vector4d

Vector4ub

Vector4b

Vector4us

Vector4s

Vector4ui

Vector4i

Matrix2x2

Matrix2x2h

Matrix2x2d

Matrix2x3

Matrix2x3h

Matrix2x3d

Matrix2x4

Matrix2x4h

Matrix2x4d

Matrix3x2

Matrix3x2h

Matrix3x2d

Matrix3x3

Matrix3x3h

Matrix3x3d

Matrix3x4

Matrix3x4h

Matrix3x4d

Matrix4x2

Matrix4x2h

Matrix4x2d

Matrix4x3

Matrix4x3h

Matrix4x3d

Matrix4x4

Matrix4x4h

Matrix4x4d

Range1D

Range1Dh

Range1Dd

Range1Di

Range2D

Range2Dh

Range2Dd

Range2Di

Range3D

Range3Dh

Range3Dd

Range3Di

Complex

Complexd

DualComplex

DualComplexd

Quaternion

Quaterniond

DualQuaternion

DualQuaterniond

Deg

Degh

Degh

Rad

Radh

Radd

const void*, type is not preserved. For convenience it's possible to retrieve the value by calling field<const T*>() with an arbitrary T but the user has to ensure the type is correct.

void*, type is not preserved. For convenience it's possible to retrieve the value by calling field<T*>() with an arbitrary T but the user has to ensure the type is correct.

The field is offset-only, i.e. doesn't contain the data views directly but referes to unspecified external data. Set implicitly by the SceneFieldData::SceneFieldData(SceneField, std::size_t, SceneMappingType, std::size_t, std::ptrdiff_t, SceneFieldType, std::size_t, std::ptrdiff_t, UnsignedShort, SceneFieldFlags) constructor, can't be used for any other constructor.

The field has an ordered object mapping, i.e. a monotonically increasing sequence. Object IDs in fields marked with this flag can be looked up with an complexity, gaps and duplicates are possible.

Note that validity of the object mapping data isn't checked in any way and if the data doesn't correspond to rules of the flag, queries such as SceneData::findFieldObjectOffset() may return a wrong value.

If a field has neither this nor the SceneFieldFlag::ImplicitMapping flag, it's assumed to be unordered, with an lookup complexity.

The field has an implicit object mapping, i.e. a contiguous sequence from 0 up to size of the field. A superset of SceneFieldFlag::OrderedMapping. Object IDs in fields marked with this flag can be looked up with an complexity, but the field is restricted to exactly one value for each object.

Note that validity of the object mapping data isn't checked in any way and if the data doesn't correspond to rules of the flag, queries such as SceneData::findFieldObjectOffset() may return a wrong value.

If a field has neither this nor the SceneFieldFlag::OrderedMapping flag, it's assumed to be unordered, with an lookup complexity.

One-dimensional texture. The TextureData::image() ID corresponds to an image from AbstractImporter::image1D().

One-dimensional texture array. The TextureData::image() ID corresponds to an image from AbstractImporter::image2D().

Two-dimensional texture. The TextureData::image() ID corresponds to an image from AbstractImporter::image2D().

Two-dimensional texture array. The TextureData::image() ID corresponds to an image from AbstractImporter::image3D().

Three-dimensional texture. The TextureData::image() ID corresponds to an image from AbstractImporter::image3D().

Cube map texture. The TextureData::image() ID corresponds to an image from AbstractImporter::image3D(), which is assumed to have exactly 6 layers in order +X, -X, +Y, -Y, +Z, -Z.

Cube map texture array. The TextureData::image() ID corresponds to an image from AbstractImporter::image3D(), which is assumed to have the layer count divisible by 6, each set in order +X, -X, +Y, -Y, +Z, -Z.

Cube map texture.