diff --git a/doc/changelog.dox b/doc/changelog.dox
index efb0a290a..26ca1c203 100644
--- a/doc/changelog.dox
+++ b/doc/changelog.dox
@@ -634,7 +634,7 @@ See also:
     etc.
 -   @ref Trade::SceneData constructor taking a @ref std::vector of 2D and 3D
     children is deprecated in favor of the new scene representation. Use
-    @ref Trade::SceneData::SceneData(SceneObjectType, UnsignedLong, Containers::Array<char>&&, Containers::Array<SceneFieldData>&&, const void*)
+    @ref Trade::SceneData::SceneData(SceneMappingType, UnsignedLong, Containers::Array<char>&&, Containers::Array<SceneFieldData>&&, const void*)
     instead.
 -   @cpp Trade::SceneData::children2D() @ce and
     @cpp Trade::SceneData::children3D() @ce are deprecated in favor of the
@@ -828,7 +828,7 @@ See also:
     desired use case anymore.
 -   @ref Trade::SceneData constructor taking a @ref std::vector of 2D and 3D
     children that got deprecated in favor of
-    @ref Trade::SceneData::SceneData(SceneObjectType, UnsignedLong, Containers::Array<char>&&, Containers::Array<SceneFieldData>&&, const void*)
+    @ref Trade::SceneData::SceneData(SceneMappingType, UnsignedLong, Containers::Array<char>&&, Containers::Array<SceneFieldData>&&, const void*)
     no longer accepts a scene that has both 2D and 3D children.
 -   The deprecated @cpp Trade::AbstractImporter::object*DCount() @ce,
     @cpp Trade::AbstractImporter::object*DForName() @ce,
diff --git a/src/Magnum/MeshTools/sceneconverter.cpp b/src/Magnum/MeshTools/sceneconverter.cpp
index 98fbd95f8..d538fb721 100644
--- a/src/Magnum/MeshTools/sceneconverter.cpp
+++ b/src/Magnum/MeshTools/sceneconverter.cpp
@@ -386,8 +386,8 @@ used.)")
 
         struct SceneInfo {
             UnsignedInt scene;
-            Trade::SceneObjectType objectType;
-            UnsignedLong objectCount;
+            Trade::SceneMappingType mappingType;
+            UnsignedLong mappingBound;
             Containers::Array<SceneFieldInfo> fields;
             std::size_t dataSize;
             std::string name;
@@ -410,8 +410,8 @@ used.)")
 
             SceneInfo info{};
             info.scene = i;
-            info.objectType = scene->objectType();
-            info.objectCount = scene->objectCount();
+            info.mappingType = scene->mappingType();
+            info.mappingBound = scene->mappingBound();
             info.dataSize = scene->data().size();
             info.name = importer->sceneName(i);
             for(UnsignedInt j = 0; j != scene->fieldCount(); ++j) {
@@ -666,7 +666,7 @@ used.)")
             d << "Scene" << info.scene << Debug::nospace << ":";
             if(!info.name.empty()) d << info.name;
             d << Debug::newline;
-            d << "   " << info.objectCount << "objects," << info.objectType
+            d << "    bound:" << info.mappingBound << "objects," << info.mappingType
                 << "(" << Debug::nospace << Utility::formatString("{:.1f}", info.dataSize/1024.0f) << "kB)";
 
             for(const SceneFieldInfo& field: info.fields) {
diff --git a/src/Magnum/Trade/AbstractImporter.cpp b/src/Magnum/Trade/AbstractImporter.cpp
index ec15b7ef2..f63e0b63f 100644
--- a/src/Magnum/Trade/AbstractImporter.cpp
+++ b/src/Magnum/Trade/AbstractImporter.cpp
@@ -538,13 +538,13 @@ void AbstractImporter::populateCachedScenes() {
                except for the above, also because it doesn't take into account
                the restriction for unique-functioning objects. */
             if(_cachedScenes->scenes[i]->is2D())
-                _cachedScenes->object2DCount = Math::max(_cachedScenes->object2DCount, UnsignedInt(_cachedScenes->scenes[i]->objectCount()));
+                _cachedScenes->object2DCount = Math::max(_cachedScenes->object2DCount, UnsignedInt(_cachedScenes->scenes[i]->mappingBound()));
             if(_cachedScenes->scenes[i]->is3D())
-                _cachedScenes->object3DCount = Math::max(_cachedScenes->object3DCount, UnsignedInt(_cachedScenes->scenes[i]->objectCount()));
+                _cachedScenes->object3DCount = Math::max(_cachedScenes->object3DCount, UnsignedInt(_cachedScenes->scenes[i]->mappingBound()));
 
             /* Ensure the newly added objects for each scene don't overlap each
                other */
-            newObjectOffset = Math::max(newObjectOffset, _cachedScenes->scenes[i]->objectCount());
+            newObjectOffset = Math::max(newObjectOffset, _cachedScenes->scenes[i]->mappingBound());
         }
     }
 
@@ -618,7 +618,7 @@ std::string AbstractImporter::doObject2DName(const UnsignedInt id) {
     for(UnsignedInt i = 0; i != _cachedScenes->scenes.size(); ++i) {
         if(!_cachedScenes->scenes[i] ||
            !_cachedScenes->scenes[i]->is2D() ||
-           _cachedScenes->scenes[i]->objectCount() <= id)
+           _cachedScenes->scenes[i]->mappingBound() <= id)
             continue;
 
         if(Containers::Optional<Int> parent = _cachedScenes->scenes[i]->parentFor(id))
@@ -643,7 +643,7 @@ Containers::Pointer<ObjectData2D> AbstractImporter::doObject2D(const UnsignedInt
     populateCachedScenes();
 
     /* Find the first 2D scene with this object, which we'll detect from the
-       object count reported for the scene, whether it's 2D or 3D, and a
+       mapping bound reported for the scene, whether it's 2D or 3D, and a
        presence of a parent attribute. If a parent attribute is not present, it
        means the object isn't a part of this scene, in which case we skip it.
        It could also mean isn't a part of the hierarchy and is standalone
@@ -652,7 +652,7 @@ Containers::Pointer<ObjectData2D> AbstractImporter::doObject2D(const UnsignedInt
     std::size_t sceneCandidate = ~std::size_t{};
     for(std::size_t i = 0; i != _cachedScenes->scenes.size(); ++i) {
         const Containers::Optional<SceneData>& scene = _cachedScenes->scenes[i];
-        if(scene && scene->is2D() && id < scene->objectCount() && scene->parentFor(id)) {
+        if(scene && scene->is2D() && id < scene->mappingBound() && scene->parentFor(id)) {
             sceneCandidate = i;
             break;
         }
@@ -796,7 +796,7 @@ std::string AbstractImporter::doObject3DName(const UnsignedInt id) {
     for(UnsignedInt i = 0; i != _cachedScenes->scenes.size(); ++i) {
         if(!_cachedScenes->scenes[i] ||
            !_cachedScenes->scenes[i]->is3D() ||
-           _cachedScenes->scenes[i]->objectCount() <= id)
+           _cachedScenes->scenes[i]->mappingBound() <= id)
             continue;
 
         if(Containers::Optional<Int> parent = _cachedScenes->scenes[i]->parentFor(id))
@@ -821,7 +821,7 @@ Containers::Pointer<ObjectData3D> AbstractImporter::doObject3D(const UnsignedInt
     populateCachedScenes();
 
     /* Find the first 3D scene with this object, which we'll detect from the
-       object count reported for the scene, whether it's 2D or 3D, and a
+       mapping bound reported for the scene, whether it's 2D or 3D, and a
        presence of a parent attribute. If a parent attribute is not present, it
        means the object isn't a part of this scene, in which case we skip it.
        It could also mean isn't a part of the hierarchy and is standalone
@@ -830,7 +830,7 @@ Containers::Pointer<ObjectData3D> AbstractImporter::doObject3D(const UnsignedInt
     std::size_t sceneCandidate = ~std::size_t{};
     for(std::size_t i = 0; i != _cachedScenes->scenes.size(); ++i) {
         const Containers::Optional<SceneData>& scene = _cachedScenes->scenes[i];
-        if(scene && scene->is3D() && id < scene->objectCount() && scene->parentFor(id)) {
+        if(scene && scene->is3D() && id < scene->mappingBound() && scene->parentFor(id)) {
             sceneCandidate = i;
             break;
         }
diff --git a/src/Magnum/Trade/Implementation/sceneTools.h b/src/Magnum/Trade/Implementation/sceneTools.h
index 45d451d5f..6336dc43e 100644
--- a/src/Magnum/Trade/Implementation/sceneTools.h
+++ b/src/Magnum/Trade/Implementation/sceneTools.h
@@ -59,29 +59,30 @@ template<class T> void sceneCombineCopyObjects(const Containers::ArrayView<const
 
         /* If the field has null object data, no need to copy anything. This
            covers reserved fields but also fields of zero size. */
-        if(!fields[i].objectData()) continue;
+        if(!fields[i].mappingData()) continue;
 
-        const Containers::StridedArrayView1D<const void> src = fields[i].objectData();
+        const Containers::StridedArrayView1D<const void> src = fields[i].mappingData();
         const Containers::StridedArrayView1D<T> dst = Containers::arrayCast<1, T>(itemViews[mapping]);
-        if(fields[i].objectType() == SceneObjectType::UnsignedByte)
+        if(fields[i].mappingType() == SceneMappingType::UnsignedByte)
             copyOrCastInto(Containers::arrayCast<const UnsignedByte>(src), dst);
-        else if(fields[i].objectType() == SceneObjectType::UnsignedShort)
+        else if(fields[i].mappingType() == SceneMappingType::UnsignedShort)
             copyOrCastInto(Containers::arrayCast<const UnsignedShort>(src), dst);
-        else if(fields[i].objectType() == SceneObjectType::UnsignedInt)
+        else if(fields[i].mappingType() == SceneMappingType::UnsignedInt)
             copyOrCastInto(Containers::arrayCast<const UnsignedInt>(src), dst);
-        else if(fields[i].objectType() == SceneObjectType::UnsignedLong)
+        else if(fields[i].mappingType() == SceneMappingType::UnsignedLong)
             copyOrCastInto(Containers::arrayCast<const UnsignedLong>(src), dst);
         else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
     }
 }
 
-/* Combine fields of varying object type together into a SceneData of a single
-   given objectType. The fields are expected to point to existing object/field
-   memory, which will be then copied to the resulting scene. If you supply a
-   field with null object or field data, the object or field data will not get
-   copied, only a placeholder for copying the data later will be allocated. If
-   you however need to have placeholder object data shared among
-   Offset-only fields are not allowed.
+/* Combine fields of varying mapping type together into a SceneData of a single
+   given mappingType. The fields are expected to point to existing
+   mapping/field memory, which will be then copied to the resulting scene. If
+   you supply a field with null mapping or field data, the mapping or field
+   data will not get copied, only a placeholder for copying the data later will
+   be allocated. If you however need to have placeholder mapping data shared
+   among multiple fields you have to allocate them upfront. Offset-only fields
+   are not allowed.
 
    The resulting fields are always tightly packed (not interleaved).
 
@@ -90,9 +91,9 @@ template<class T> void sceneCombineCopyObjects(const Containers::ArrayView<const
    with different lengths will assert. */
 /** @todo when published, add an initializer_list overload and turn all
     internal asserts into (tested!) message asserts */
-inline SceneData sceneCombine(const SceneObjectType objectType, const UnsignedLong objectCount, const Containers::ArrayView<const SceneFieldData> fields) {
-    const std::size_t objectTypeSize = sceneObjectTypeSize(objectType);
-    const std::size_t objectTypeAlignment = sceneObjectTypeAlignment(objectType);
+inline SceneData sceneCombine(const SceneMappingType mappingType, const UnsignedLong mappingBound, const Containers::ArrayView<const SceneFieldData> fields) {
+    const std::size_t mappingTypeSize = sceneMappingTypeSize(mappingType);
+    const std::size_t mappingTypeAlignment = sceneMappingTypeAlignment(mappingType);
 
     /* Go through all fields and collect ArrayTuple allocations for these */
     std::unordered_map<const void*, UnsignedInt> objectMappings;
@@ -110,12 +111,12 @@ inline SceneData sceneCombine(const SceneObjectType objectType, const UnsignedLo
         const SceneFieldData& field = fields[i];
         CORRADE_INTERNAL_ASSERT(!field.isOffsetOnly());
 
-        /* Object data. Allocate if the view is a placeholder of if it wasn't
+        /* Mapping data. Allocate if the view is a placeholder of if it wasn't
            used by other fields yet. */
         std::pair<std::unordered_map<const void*, UnsignedInt>::iterator, bool> inserted;
-        if(field.objectData().data())
-            inserted = objectMappings.emplace(field.objectData().data(), itemViewOffset);
-        if(field.objectData().data() && !inserted.second) {
+        if(field.mappingData().data())
+            inserted = objectMappings.emplace(field.mappingData().data(), itemViewOffset);
+        if(field.mappingData().data() && !inserted.second) {
             itemViewMappings[i].first() = inserted.first->second;
             /* Expect that fields sharing the same object mapping view have the
                exact same length (the length gets stored in the output view
@@ -145,7 +146,7 @@ inline SceneData sceneCombine(const SceneObjectType objectType, const UnsignedLo
             CORRADE_INTERNAL_ASSERT(itemViews[inserted.first->second].size()[0] == field.size());
         } else {
             itemViewMappings[i].first() = itemViewOffset;
-            arrayAppend(items, InPlaceInit, NoInit, std::size_t(field.size()), objectTypeSize, objectTypeAlignment, itemViews[itemViewOffset]);
+            arrayAppend(items, InPlaceInit, NoInit, std::size_t(field.size()), mappingTypeSize, mappingTypeAlignment, itemViews[itemViewOffset]);
             ++itemViewOffset;
         }
 
@@ -162,13 +163,13 @@ inline SceneData sceneCombine(const SceneObjectType objectType, const UnsignedLo
     CORRADE_INTERNAL_ASSERT(!outData.deleter());
 
     /* Copy the object data over and cast them as necessary */
-    if(objectType == SceneObjectType::UnsignedByte)
+    if(mappingType == SceneMappingType::UnsignedByte)
         sceneCombineCopyObjects<UnsignedByte>(fields, itemViews, itemViewMappings);
-    else if(objectType == SceneObjectType::UnsignedShort)
+    else if(mappingType == SceneMappingType::UnsignedShort)
         sceneCombineCopyObjects<UnsignedShort>(fields, itemViews, itemViewMappings);
-    else if(objectType == SceneObjectType::UnsignedInt)
+    else if(mappingType == SceneMappingType::UnsignedInt)
         sceneCombineCopyObjects<UnsignedInt>(fields, itemViews, itemViewMappings);
-    else if(objectType == SceneObjectType::UnsignedLong)
+    else if(mappingType == SceneMappingType::UnsignedLong)
         sceneCombineCopyObjects<UnsignedLong>(fields, itemViews, itemViewMappings);
 
     /* Copy the field data over. No special handling needed here. */
@@ -187,7 +188,7 @@ inline SceneData sceneCombine(const SceneObjectType objectType, const UnsignedLo
         outFields[i] = SceneFieldData{fields[i].name(), itemViews[itemViewMappings[i].first()], fields[i].fieldType(), itemViews[itemViewMappings[i].second()], fields[i].fieldArraySize()};
     }
 
-    return SceneData{objectType, objectCount, std::move(outData), std::move(outFields)};
+    return SceneData{mappingType, mappingBound, std::move(outData), std::move(outFields)};
 }
 
 /* Creates a SceneData copy where each object has at most one of the fields
@@ -205,7 +206,7 @@ inline SceneData sceneCombine(const SceneObjectType objectType, const UnsignedLo
     internal asserts into (tested!) message asserts */
 inline SceneData sceneConvertToSingleFunctionObjects(const SceneData& scene, Containers::ArrayView<const SceneField> fieldsToConvert, const UnsignedInt newObjectOffset) {
     /** @todo assert for really high object counts (where this cast would fail) */
-    Containers::Array<UnsignedInt> objectAttachmentCount{ValueInit, std::size_t(scene.objectCount())};
+    Containers::Array<UnsignedInt> objectAttachmentCount{ValueInit, std::size_t(scene.mappingBound())};
     for(const SceneField field: fieldsToConvert) {
         CORRADE_INTERNAL_ASSERT(field != SceneField::Parent);
 
@@ -217,7 +218,7 @@ inline SceneData sceneConvertToSingleFunctionObjects(const SceneData& scene, Con
         /** @todo use a statically-allocated array & Into() in a loop instead
             once this is more than a private backwards-compatibility utility
             where PERF WHATEVER WHO CARES */
-        for(const UnsignedInt object: scene.objectsAsArray(*fieldId)) {
+        for(const UnsignedInt object: scene.mappingAsArray(*fieldId)) {
             CORRADE_INTERNAL_ASSERT(object < objectAttachmentCount.size());
             ++objectAttachmentCount[object];
         }
@@ -249,25 +250,25 @@ inline SceneData sceneConvertToSingleFunctionObjects(const SceneData& scene, Con
     }
 
     /* Combine the fields into a new SceneData */
-    SceneData out = sceneCombine(SceneObjectType::UnsignedInt, Math::max(scene.objectCount(), UnsignedLong(newObjectOffset) + objectsToAdd), fields);
+    SceneData out = sceneCombine(SceneMappingType::UnsignedInt, Math::max(scene.mappingBound(), UnsignedLong(newObjectOffset) + objectsToAdd), fields);
 
     /* Copy existing parent object/field data to a prefix of the output */
-    const Containers::StridedArrayView1D<UnsignedInt> outParentObjects = out.mutableObjects<UnsignedInt>(parentFieldId);
+    const Containers::StridedArrayView1D<UnsignedInt> outParentMapping = out.mutableMapping<UnsignedInt>(parentFieldId);
     const Containers::StridedArrayView1D<Int> outParents = out.mutableField<Int>(parentFieldId);
-    CORRADE_INTERNAL_ASSERT_OUTPUT(scene.parentsInto(0, outParentObjects, outParents) == scene.fieldSize(parentFieldId));
+    CORRADE_INTERNAL_ASSERT_OUTPUT(scene.parentsInto(0, outParentMapping, outParents) == scene.fieldSize(parentFieldId));
 
     /* List new objects at the end of the extended parent field */
-    const Containers::StridedArrayView1D<UnsignedInt> newParentObjects = outParentObjects.suffix(scene.fieldSize(parentFieldId));
+    const Containers::StridedArrayView1D<UnsignedInt> newParentMapping = outParentMapping.suffix(scene.fieldSize(parentFieldId));
     const Containers::StridedArrayView1D<Int> newParents = outParents.suffix(scene.fieldSize(parentFieldId));
-    for(std::size_t i = 0; i != newParentObjects.size(); ++i) {
-        newParentObjects[i] = newObjectOffset + i;
+    for(std::size_t i = 0; i != newParentMapping.size(); ++i) {
+        newParentMapping[i] = newObjectOffset + i;
         newParents[i] = -1;
     }
 
     /* Clear the objectAttachmentCount array to reuse it below */
     /** @todo use a BitArray instead once it exists? */
     constexpr UnsignedInt zero[1]{};
-    Utility::copy(Containers::stridedArrayView(zero).broadcasted<0>(scene.objectCount()), objectAttachmentCount);
+    Utility::copy(Containers::stridedArrayView(zero).broadcasted<0>(scene.mappingBound()), objectAttachmentCount);
 
     /* For objects with multiple fields move the extra fields to newly added
        children */
@@ -277,7 +278,7 @@ inline SceneData sceneConvertToSingleFunctionObjects(const SceneData& scene, Con
             const Containers::Optional<UnsignedInt> fieldId = scene.findFieldId(field);
             if(!fieldId) continue;
 
-            for(UnsignedInt& fieldObject: out.mutableObjects<UnsignedInt>(*fieldId)) {
+            for(UnsignedInt& fieldObject: out.mutableMapping<UnsignedInt>(*fieldId)) {
                 /* If the object is not new (could happen when an object
                    mapping array is shared among multiple fields, in which case
                    it *might* have been updated already to an ID larger than
@@ -288,7 +289,7 @@ inline SceneData sceneConvertToSingleFunctionObjects(const SceneData& scene, Con
                     /* Use the old object as a parent of the new object */
                     newParents[newParentIndex] = fieldObject;
                     /* Assign the field to the new object */
-                    fieldObject = newParentObjects[newParentIndex];
+                    fieldObject = newParentMapping[newParentIndex];
                     /* Move to the next reserved object */
                     ++newParentIndex;
                 } else ++objectAttachmentCount[fieldObject];
diff --git a/src/Magnum/Trade/SceneData.cpp b/src/Magnum/Trade/SceneData.cpp
index 28a482d83..44a19a77c 100644
--- a/src/Magnum/Trade/SceneData.cpp
+++ b/src/Magnum/Trade/SceneData.cpp
@@ -47,12 +47,12 @@
 
 namespace Magnum { namespace Trade {
 
-Debug& operator<<(Debug& debug, const SceneObjectType value) {
-    debug << "Trade::SceneObjectType" << Debug::nospace;
+Debug& operator<<(Debug& debug, const SceneMappingType value) {
+    debug << "Trade::SceneMappingType" << Debug::nospace;
 
     switch(value) {
         /* LCOV_EXCL_START */
-        #define _c(value) case SceneObjectType::value: return debug << "::" #value;
+        #define _c(value) case SceneMappingType::value: return debug << "::" #value;
         _c(UnsignedByte)
         _c(UnsignedInt)
         _c(UnsignedShort)
@@ -64,40 +64,40 @@ Debug& operator<<(Debug& debug, const SceneObjectType value) {
     return debug << "(" << Debug::nospace << reinterpret_cast<void*>(UnsignedByte(value)) << Debug::nospace << ")";
 }
 
-UnsignedInt sceneObjectTypeSize(const SceneObjectType type) {
+UnsignedInt sceneMappingTypeSize(const SceneMappingType type) {
     #ifdef CORRADE_TARGET_GCC
     #pragma GCC diagnostic push
     #pragma GCC diagnostic error "-Wswitch"
     #endif
     switch(type) {
-        case SceneObjectType::UnsignedByte: return 1;
-        case SceneObjectType::UnsignedShort: return 2;
-        case SceneObjectType::UnsignedInt: return 4;
-        case SceneObjectType::UnsignedLong: return 8;
+        case SceneMappingType::UnsignedByte: return 1;
+        case SceneMappingType::UnsignedShort: return 2;
+        case SceneMappingType::UnsignedInt: return 4;
+        case SceneMappingType::UnsignedLong: return 8;
     }
     #ifdef CORRADE_TARGET_GCC
     #pragma GCC diagnostic pop
     #endif
 
-    CORRADE_ASSERT_UNREACHABLE("Trade::sceneObjectTypeSize(): invalid type" << type, {});
+    CORRADE_ASSERT_UNREACHABLE("Trade::sceneMappingTypeSize(): invalid type" << type, {});
 }
 
-UnsignedInt sceneObjectTypeAlignment(const SceneObjectType type) {
+UnsignedInt sceneMappingTypeAlignment(const SceneMappingType type) {
     #ifdef CORRADE_TARGET_GCC
     #pragma GCC diagnostic push
     #pragma GCC diagnostic error "-Wswitch"
     #endif
     switch(type) {
-        case SceneObjectType::UnsignedByte: return 1;
-        case SceneObjectType::UnsignedShort: return 2;
-        case SceneObjectType::UnsignedInt: return 4;
-        case SceneObjectType::UnsignedLong: return 8;
+        case SceneMappingType::UnsignedByte: return 1;
+        case SceneMappingType::UnsignedShort: return 2;
+        case SceneMappingType::UnsignedInt: return 4;
+        case SceneMappingType::UnsignedLong: return 8;
     }
     #ifdef CORRADE_TARGET_GCC
     #pragma GCC diagnostic pop
     #endif
 
-    CORRADE_ASSERT_UNREACHABLE("Trade::sceneObjectTypeAlignment(): invalid type" << type, {});
+    CORRADE_ASSERT_UNREACHABLE("Trade::sceneMappingTypeAlignment(): invalid type" << type, {});
 }
 
 Debug& operator<<(Debug& debug, const SceneField value) {
@@ -473,7 +473,7 @@ UnsignedInt sceneFieldTypeAlignment(const SceneFieldType type) {
     CORRADE_ASSERT_UNREACHABLE("Trade::sceneFieldTypeAlignment(): invalid type" << type, {});
 }
 
-SceneFieldData::SceneFieldData(const SceneField name, const Containers::StridedArrayView2D<const char>& objectData, const SceneFieldType fieldType, const Containers::StridedArrayView2D<const char>& fieldData, const UnsignedShort fieldArraySize) noexcept: SceneFieldData{name, {}, Containers::StridedArrayView1D<const void>{{objectData.data(), ~std::size_t{}}, objectData.size()[0], objectData.stride()[0]}, fieldType, Containers::StridedArrayView1D<const void>{{fieldData.data(), ~std::size_t{}}, fieldData.size()[0], fieldData.stride()[0]}, fieldArraySize} {
+SceneFieldData::SceneFieldData(const SceneField name, const Containers::StridedArrayView2D<const char>& mappingData, const SceneFieldType fieldType, const Containers::StridedArrayView2D<const char>& fieldData, const UnsignedShort fieldArraySize) noexcept: SceneFieldData{name, {}, Containers::StridedArrayView1D<const void>{{mappingData.data(), ~std::size_t{}}, mappingData.size()[0], mappingData.stride()[0]}, fieldType, Containers::StridedArrayView1D<const void>{{fieldData.data(), ~std::size_t{}}, fieldData.size()[0], fieldData.stride()[0]}, fieldArraySize} {
     /* Yes, this calls into a constexpr function defined in the header --
        because I feel that makes more sense than duplicating the full assert
        logic */
@@ -484,14 +484,14 @@ SceneFieldData::SceneFieldData(const SceneField name, const Containers::StridedA
         "Trade::SceneFieldData: second field view dimension size" << fieldData.size()[1] << "doesn't match" << fieldType, );
     #endif
 
-    if(objectData.size()[1] == 8) _objectType = SceneObjectType::UnsignedLong;
-    else if(objectData.size()[1] == 4) _objectType = SceneObjectType::UnsignedInt;
-    else if(objectData.size()[1] == 2) _objectType = SceneObjectType::UnsignedShort;
-    else if(objectData.size()[1] == 1) _objectType = SceneObjectType::UnsignedByte;
-    else CORRADE_ASSERT_UNREACHABLE("Trade::SceneFieldData: expected second object view dimension size 1, 2, 4 or 8 but got" << objectData.size()[1], );
+    if(mappingData.size()[1] == 8) _mappingType = SceneMappingType::UnsignedLong;
+    else if(mappingData.size()[1] == 4) _mappingType = SceneMappingType::UnsignedInt;
+    else if(mappingData.size()[1] == 2) _mappingType = SceneMappingType::UnsignedShort;
+    else if(mappingData.size()[1] == 1) _mappingType = SceneMappingType::UnsignedByte;
+    else CORRADE_ASSERT_UNREACHABLE("Trade::SceneFieldData: expected second mapping view dimension size 1, 2, 4 or 8 but got" << mappingData.size()[1], );
 
+    CORRADE_ASSERT(mappingData.isContiguous<1>(), "Trade::SceneFieldData: second mapping view dimension is not contiguous", );
     CORRADE_ASSERT(fieldData.isContiguous<1>(), "Trade::SceneFieldData: second field view dimension is not contiguous", );
-    CORRADE_ASSERT(objectData.isContiguous<1>(), "Trade::SceneFieldData: second object view dimension is not contiguous", );
 }
 
 Containers::Array<SceneFieldData> sceneFieldDataNonOwningArray(const Containers::ArrayView<const SceneFieldData> view) {
@@ -499,19 +499,19 @@ Containers::Array<SceneFieldData> sceneFieldDataNonOwningArray(const Containers:
     return Containers::Array<SceneFieldData>{const_cast<SceneFieldData*>(view.data()), view.size(), reinterpret_cast<void(*)(SceneFieldData*, std::size_t)>(Implementation::nonOwnedArrayDeleter)};
 }
 
-SceneData::SceneData(const SceneObjectType objectType, const UnsignedLong objectCount, Containers::Array<char>&& data, Containers::Array<SceneFieldData>&& fields, const void* const importerState) noexcept: _dataFlags{DataFlag::Owned|DataFlag::Mutable}, _objectType{objectType}, _dimensions{}, _objectCount{objectCount}, _importerState{importerState}, _fields{std::move(fields)}, _data{std::move(data)} {
-    /* Check that object type is large enough */
+SceneData::SceneData(const SceneMappingType mappingType, const UnsignedLong mappingBound, Containers::Array<char>&& data, Containers::Array<SceneFieldData>&& fields, const void* const importerState) noexcept: _dataFlags{DataFlag::Owned|DataFlag::Mutable}, _mappingType{mappingType}, _dimensions{}, _mappingBound{mappingBound}, _importerState{importerState}, _fields{std::move(fields)}, _data{std::move(data)} {
+    /* Check that mapping type is large enough */
     CORRADE_ASSERT(
-        (objectType == SceneObjectType::UnsignedByte && objectCount <= 0xffull) ||
-        (objectType == SceneObjectType::UnsignedShort && objectCount <= 0xffffull) ||
-        (objectType == SceneObjectType::UnsignedInt && objectCount <= 0xffffffffull) ||
-        objectType == SceneObjectType::UnsignedLong,
-        "Trade::SceneData:" << objectType << "is too small for" << objectCount << "objects", );
+        (mappingType == SceneMappingType::UnsignedByte && mappingBound <= 0xffull) ||
+        (mappingType == SceneMappingType::UnsignedShort && mappingBound <= 0xffffull) ||
+        (mappingType == SceneMappingType::UnsignedInt && mappingBound <= 0xffffffffull) ||
+        mappingType == SceneMappingType::UnsignedLong,
+        "Trade::SceneData:" << mappingType << "is too small for" << mappingBound << "objects", );
 
     #ifndef CORRADE_NO_ASSERT
     /* Check various assumptions about field data */
     Math::BoolVector<12> fieldsPresent; /** @todo some constant for this */
-    const UnsignedInt objectTypeSize = sceneObjectTypeSize(_objectType);
+    const UnsignedInt mappingTypeSize = sceneMappingTypeSize(_mappingType);
     #endif
     UnsignedInt transformationField = ~UnsignedInt{};
     UnsignedInt translationField = ~UnsignedInt{};
@@ -526,17 +526,17 @@ SceneData::SceneData(const SceneObjectType objectType, const UnsignedLong object
         const SceneFieldData& field = _fields[i];
 
         #ifndef CORRADE_NO_ASSERT
-        /* The object type has to be the same among all fields. Technically it
+        /* The mapping type has to be the same among all fields. Technically it
            wouldn't need to be, but if there's 60k objects then using a 8bit
            type for certain fields would mean only the first 256 objects can be
            referenced, which makes no practical sense, and to improve the
            situation there would need to be some additional per-field object
-           offset and ... it's simpler to just require the object type to be
+           offset and ... it's simpler to just require the mapping type to be
            large enough to reference all objects (checked outside of the loop
            above) and that it's the same for all fields. This also makes it
            more convenient for the user. */
-        CORRADE_ASSERT(field._objectType == _objectType,
-            "Trade::SceneData: inconsistent object type, got" << field._objectType << "for field" << i << "but expected" << _objectType, );
+        CORRADE_ASSERT(field._mappingType == _mappingType,
+            "Trade::SceneData: inconsistent mapping type, got" << field._mappingType << "for field" << i << "but expected" << _mappingType, );
 
         /* We could check that object indices are in bounds, but that's rather
            expensive. OTOH it's fine if field size is larger than object count,
@@ -558,7 +558,7 @@ SceneData::SceneData(const SceneObjectType objectType, const UnsignedLong object
                 "Trade::SceneData: duplicate field" << _fields[i]._name, );
         }
 
-        /* Check that both the object and field view fits into the provided
+        /* Check that both the mapping and field view fits into the provided
            data array. If the field is empty, we don't check anything --
            accessing the memory would be invalid anyway and enforcing this
            would lead to unnecessary friction with optional fields. */
@@ -566,19 +566,19 @@ SceneData::SceneData(const SceneObjectType objectType, const UnsignedLong object
             const UnsignedInt fieldTypeSize = sceneFieldTypeSize(field._fieldType)*
                 (field._fieldArraySize ? field._fieldArraySize : 1);
             if(field._isOffsetOnly) {
-                const std::size_t objectSize = field._objectData.offset + (field._size - 1)*field._objectStride + objectTypeSize;
+                const std::size_t mappingSize = field._mappingData.offset + (field._size - 1)*field._mappingStride + mappingTypeSize;
                 const std::size_t fieldSize = field._fieldData.offset + (field._size - 1)*field._fieldStride + fieldTypeSize;
-                CORRADE_ASSERT(objectSize <= _data.size(),
-                    "Trade::SceneData: offset-only object data of field" << i << "span" << objectSize << "bytes but passed data array has only" << _data.size(), );
+                CORRADE_ASSERT(mappingSize <= _data.size(),
+                    "Trade::SceneData: offset-only mapping data of field" << i << "span" << mappingSize << "bytes but passed data array has only" << _data.size(), );
                 CORRADE_ASSERT(fieldSize <= _data.size(),
                     "Trade::SceneData: offset-only field data of field" << i << "span" << fieldSize << "bytes but passed data array has only" << _data.size(), );
             } else {
-                const void* const objectBegin = field._objectData.pointer;
+                const void* const mappingBegin = field._mappingData.pointer;
                 const void* const fieldBegin = field._fieldData.pointer;
-                const void* const objectEnd = static_cast<const char*>(field._objectData.pointer) + (field._size - 1)*field._objectStride + objectTypeSize;
+                const void* const mappingEnd = static_cast<const char*>(field._mappingData.pointer) + (field._size - 1)*field._mappingStride + mappingTypeSize;
                 const void* const fieldEnd = static_cast<const char*>(field._fieldData.pointer) + (field._size - 1)*field._fieldStride + fieldTypeSize;
-                CORRADE_ASSERT(objectBegin >= _data.begin() && objectEnd <= _data.end(),
-                    "Trade::SceneData: object data [" << Debug::nospace << objectBegin << Debug::nospace << ":" << Debug::nospace << objectEnd << Debug::nospace << "] of field" << i << "are not contained in passed data array [" << Debug::nospace << static_cast<const void*>(_data.begin()) << Debug::nospace << ":" << Debug::nospace << static_cast<const void*>(_data.end()) << Debug::nospace << "]", );
+                CORRADE_ASSERT(mappingBegin >= _data.begin() && mappingEnd <= _data.end(),
+                    "Trade::SceneData: mapping data [" << Debug::nospace << mappingBegin << Debug::nospace << ":" << Debug::nospace << mappingEnd << Debug::nospace << "] of field" << i << "are not contained in passed data array [" << Debug::nospace << static_cast<const void*>(_data.begin()) << Debug::nospace << ":" << Debug::nospace << static_cast<const void*>(_data.end()) << Debug::nospace << "]", );
                 CORRADE_ASSERT(fieldBegin >= _data.begin() && fieldEnd <= _data.end(),
                     "Trade::SceneData: field data [" << Debug::nospace << fieldBegin << Debug::nospace << ":" << Debug::nospace << fieldEnd << Debug::nospace << "] of field" << i << "are not contained in passed data array [" << Debug::nospace << static_cast<const void*>(_data.begin()) << Debug::nospace << ":" << Debug::nospace << static_cast<const void*>(_data.end()) << Debug::nospace << "]", );
             }
@@ -614,29 +614,29 @@ SceneData::SceneData(const SceneObjectType objectType, const UnsignedLong object
        effort just for an assert message. Also, compared to above, where
        "begin" was always zero, here we're always comparing four values, so the
        message for offset-only wouldn't be simpler either. */
-    const auto checkFieldObjectDataMatch = [](const SceneFieldData& a, const SceneFieldData& b) {
-        const std::size_t objectTypeSize = sceneObjectTypeSize(a._objectType);
-        const void* const aBegin = a._objectData.pointer;
-        const void* const bBegin = b._objectData.pointer;
-        const void* const aEnd = static_cast<const char*>(a._objectData.pointer) + a._size*objectTypeSize;
-        const void* const bEnd = static_cast<const char*>(b._objectData.pointer) + b._size*objectTypeSize;
+    const auto checkFieldMappingDataMatch = [](const SceneFieldData& a, const SceneFieldData& b) {
+        const std::size_t mappingTypeSize = sceneMappingTypeSize(a._mappingType);
+        const void* const aBegin = a._mappingData.pointer;
+        const void* const bBegin = b._mappingData.pointer;
+        const void* const aEnd = static_cast<const char*>(a._mappingData.pointer) + a._size*mappingTypeSize;
+        const void* const bEnd = static_cast<const char*>(b._mappingData.pointer) + b._size*mappingTypeSize;
         CORRADE_ASSERT(aBegin == bBegin && aEnd == bEnd,
-            "Trade::SceneData:" << b._name << "object data [" << Debug::nospace << bBegin << Debug::nospace << ":" << Debug::nospace << bEnd << Debug::nospace << "] is different from" << a._name << "object data [" << Debug::nospace << aBegin << Debug::nospace << ":" << Debug::nospace << aEnd << Debug::nospace << "]", );
+            "Trade::SceneData:" << b._name << "mapping data [" << Debug::nospace << bBegin << Debug::nospace << ":" << Debug::nospace << bEnd << Debug::nospace << "] is different from" << a._name << "mapping data [" << Debug::nospace << aBegin << Debug::nospace << ":" << Debug::nospace << aEnd << Debug::nospace << "]", );
     };
 
     /* All present TRS fields should share the same object mapping */
     if(translationField != ~UnsignedInt{}) {
         if(rotationField != ~UnsignedInt{})
-            checkFieldObjectDataMatch(_fields[translationField], _fields[rotationField]);
+            checkFieldMappingDataMatch(_fields[translationField], _fields[rotationField]);
         if(scalingField != ~UnsignedInt{})
-            checkFieldObjectDataMatch(_fields[translationField], _fields[scalingField]);
+            checkFieldMappingDataMatch(_fields[translationField], _fields[scalingField]);
     }
     if(rotationField != ~UnsignedInt{} && scalingField != ~UnsignedInt{})
-        checkFieldObjectDataMatch(_fields[rotationField], _fields[scalingField]);
+        checkFieldMappingDataMatch(_fields[rotationField], _fields[scalingField]);
 
     /* Mesh and materials also */
     if(meshField != ~UnsignedInt{} && meshMaterialField != ~UnsignedInt{})
-        checkFieldObjectDataMatch(_fields[meshField], _fields[meshMaterialField]);
+        checkFieldMappingDataMatch(_fields[meshField], _fields[meshMaterialField]);
     #endif
 
     /* Decide about dimensionality based on transformation type, if present */
@@ -710,18 +710,18 @@ SceneData::SceneData(const SceneObjectType objectType, const UnsignedLong object
         "Trade::SceneData: a skin field requires some transformation field to be present in order to disambiguate between 2D and 3D", );
 }
 
-SceneData::SceneData(const SceneObjectType objectType, const UnsignedLong objectCount, Containers::Array<char>&& data, const std::initializer_list<SceneFieldData> fields, const void* const importerState): SceneData{objectType, objectCount, std::move(data), Implementation::initializerListToArrayWithDefaultDeleter(fields), importerState} {}
+SceneData::SceneData(const SceneMappingType mappingType, const UnsignedLong mappingBound, Containers::Array<char>&& data, const std::initializer_list<SceneFieldData> fields, const void* const importerState): SceneData{mappingType, mappingBound, std::move(data), Implementation::initializerListToArrayWithDefaultDeleter(fields), importerState} {}
 
-SceneData::SceneData(const SceneObjectType objectType, const UnsignedLong objectCount, const DataFlags dataFlags, const Containers::ArrayView<const void> data, Containers::Array<SceneFieldData>&& fields, const void* const importerState) noexcept: SceneData{objectType, objectCount, Containers::Array<char>{const_cast<char*>(static_cast<const char*>(data.data())), data.size(), Implementation::nonOwnedArrayDeleter}, std::move(fields), importerState} {
+SceneData::SceneData(const SceneMappingType mappingType, const UnsignedLong mappingBound, const DataFlags dataFlags, const Containers::ArrayView<const void> data, Containers::Array<SceneFieldData>&& fields, const void* const importerState) noexcept: SceneData{mappingType, mappingBound, Containers::Array<char>{const_cast<char*>(static_cast<const char*>(data.data())), data.size(), Implementation::nonOwnedArrayDeleter}, std::move(fields), importerState} {
     CORRADE_ASSERT(!(dataFlags & DataFlag::Owned),
         "Trade::SceneData: can't construct with non-owned data but" << dataFlags, );
     _dataFlags = dataFlags;
 }
 
-SceneData::SceneData(const SceneObjectType objectType, const UnsignedLong objectCount, const DataFlags dataFlags, const Containers::ArrayView<const void> data, const std::initializer_list<SceneFieldData> fields, const void* const importerState): SceneData{objectType, objectCount, dataFlags, data, Implementation::initializerListToArrayWithDefaultDeleter(fields), importerState} {}
+SceneData::SceneData(const SceneMappingType mappingType, const UnsignedLong mappingBound, const DataFlags dataFlags, const Containers::ArrayView<const void> data, const std::initializer_list<SceneFieldData> fields, const void* const importerState): SceneData{mappingType, mappingBound, dataFlags, data, Implementation::initializerListToArrayWithDefaultDeleter(fields), importerState} {}
 
 #ifdef MAGNUM_BUILD_DEPRECATED
-SceneData::SceneData(std::vector<UnsignedInt> children2D, std::vector<UnsignedInt> children3D, const void* const importerState): _dataFlags{DataFlag::Owned|DataFlag::Mutable}, _objectType{SceneObjectType::UnsignedInt}, _importerState{importerState} {
+SceneData::SceneData(std::vector<UnsignedInt> children2D, std::vector<UnsignedInt> children3D, const void* const importerState): _dataFlags{DataFlag::Owned|DataFlag::Mutable}, _mappingType {SceneMappingType::UnsignedInt}, _importerState{importerState} {
     /* Assume nobody ever created a scene with both 2D and 3D children.
        (PrimitiveImporter did, but that's an exception and blame goes on me.)
        If this blows up for you, please complain. Or rather upgrade to the new
@@ -738,27 +738,27 @@ SceneData::SceneData(std::vector<UnsignedInt> children2D, std::vector<UnsignedIn
         children = children3D;
     } else _dimensions = 0;
 
-    /* Set object count to the max found child index. It's not great as it
+    /* Set mapping bound to the max found child index. It's not great as it
        doesn't take any nested object into account but SceneData created this
        way is expected to be used only through the deprecated APIs anyway,
        which don't care about this value. */
-    _objectCount = children.empty() ? 0 : Math::max(children) + 1;
+    _mappingBound = children.empty() ? 0 : Math::max(children) + 1;
 
     /* Convert the vector with top-level object IDs to the parent field, where
        all have -1 as a parent. This way the (also deprecated) children2D() /
        children3D() will return the desired values. */
-    Containers::ArrayView<UnsignedInt> objects;
+    Containers::ArrayView<UnsignedInt> mapping;
     Containers::ArrayView<Int> parents;
     _data = Containers::ArrayTuple{
-        {NoInit, children.size(), objects},
+        {NoInit, children.size(), mapping},
         {NoInit, children.size(), parents},
     };
     /* Can't use InPlaceInit as that creates an Array with a non-default
        deleter, which then trips up on an assertion when such an instance gets
        returned from AbstractImporter */
     _fields = Containers::Array<SceneFieldData>{1};
-    _fields[0] = SceneFieldData{SceneField::Parent, objects, parents};
-    Utility::copy(children, objects);
+    _fields[0] = SceneFieldData{SceneField::Parent, mapping, parents};
+    Utility::copy(children, mapping);
     constexpr Int parent[]{-1};
     Utility::copy(Containers::stridedArrayView(parent).broadcasted<0>(parents.size()), parents);
 }
@@ -776,18 +776,19 @@ Containers::ArrayView<char> SceneData::mutableData() & {
     return _data;
 }
 
-Containers::StridedArrayView1D<const void> SceneData::fieldDataObjectViewInternal(const SceneFieldData& field, const std::size_t offset, const std::size_t size) const {
+Containers::StridedArrayView1D<const void> SceneData::fieldDataMappingViewInternal(const SceneFieldData& field, const std::size_t offset, const std::size_t size) const {
     CORRADE_INTERNAL_ASSERT(offset + size <= field._size);
     return Containers::StridedArrayView1D<const void>{
         /* We're *sure* the view is correct, so faking the view size */
         {static_cast<const char*>(field._isOffsetOnly ?
-            _data.data() + field._objectData.offset : field._objectData.pointer)
-            + field._objectStride*offset, ~std::size_t{}},
-        size, field._objectStride};
+            _data.data() + field._mappingData.offset : field._mappingData.pointer)
+            + field._mappingStride*offset, ~std::size_t{}},
+        size, field._mappingStride
+    };
 }
 
-Containers::StridedArrayView1D<const void> SceneData::fieldDataObjectViewInternal(const SceneFieldData& field) const {
-    return fieldDataObjectViewInternal(field, 0, field._size);
+Containers::StridedArrayView1D<const void> SceneData::fieldDataMappingViewInternal(const SceneFieldData& field) const {
+    return fieldDataMappingViewInternal(field, 0, field._size);
 }
 
 Containers::StridedArrayView1D<const void> SceneData::fieldDataFieldViewInternal(const SceneFieldData& field, const std::size_t offset, const std::size_t size) const {
@@ -808,7 +809,7 @@ SceneFieldData SceneData::fieldData(const UnsignedInt id) const {
     CORRADE_ASSERT(id < _fields.size(),
         "Trade::SceneData::fieldData(): index" << id << "out of range for" << _fields.size() << "fields", SceneFieldData{});
     const SceneFieldData& field = _fields[id];
-    return SceneFieldData{field._name, field._objectType, fieldDataObjectViewInternal(field), field._fieldType, fieldDataFieldViewInternal(field), field._fieldArraySize};
+    return SceneFieldData{field._name, field._mappingType, fieldDataMappingViewInternal(field), field._fieldType, fieldDataFieldViewInternal(field), field._fieldArraySize};
 }
 
 SceneField SceneData::fieldName(const UnsignedInt id) const {
@@ -858,34 +859,34 @@ bool SceneData::hasField(const SceneField name) const {
 
 namespace {
 
-template<class T> std::size_t findObject(const Containers::StridedArrayView1D<const void>& objects, const UnsignedInt object) {
-    const Containers::StridedArrayView1D<const T> objectsT = Containers::arrayCast<const T>(objects);
-    const std::size_t max = objectsT.size();
+template<class T> std::size_t findObject(const Containers::StridedArrayView1D<const void>& mapping, const UnsignedInt object) {
+    const Containers::StridedArrayView1D<const T> mappingT = Containers::arrayCast<const T>(mapping);
+    const std::size_t max = mappingT.size();
     /** @todo implement something faster than O(n) when field-specific flags
         can annotate how the object mapping is done */
     for(std::size_t i = 0; i != max; ++i)
-        if(objectsT[i] == object) return i;
+        if(mappingT[i] == object) return i;
     return max;
 }
 
 }
 
 std::size_t SceneData::findFieldObjectOffsetInternal(const SceneFieldData& field, const UnsignedInt object, const std::size_t offset) const {
-    const Containers::StridedArrayView1D<const void> objects = fieldDataObjectViewInternal(field, offset, field._size - offset);
-    if(field._objectType == SceneObjectType::UnsignedInt)
-        return offset + findObject<UnsignedInt>(objects, object);
-    else if(field._objectType == SceneObjectType::UnsignedShort)
-        return offset + findObject<UnsignedShort>(objects, object);
-    else if(field._objectType == SceneObjectType::UnsignedByte)
-        return offset + findObject<UnsignedByte>(objects, object);
-    else if(field._objectType == SceneObjectType::UnsignedLong)
-        return offset + findObject<UnsignedLong>(objects, object);
+    const Containers::StridedArrayView1D<const void> mapping = fieldDataMappingViewInternal(field, offset, field._size - offset);
+    if(field._mappingType == SceneMappingType::UnsignedInt)
+        return offset + findObject<UnsignedInt>(mapping, object);
+    else if(field._mappingType == SceneMappingType::UnsignedShort)
+        return offset + findObject<UnsignedShort>(mapping, object);
+    else if(field._mappingType == SceneMappingType::UnsignedByte)
+        return offset + findObject<UnsignedByte>(mapping, object);
+    else if(field._mappingType == SceneMappingType::UnsignedLong)
+        return offset + findObject<UnsignedLong>(mapping, object);
     else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
 }
 
 Containers::Optional<std::size_t> SceneData::findFieldObjectOffset(const UnsignedInt fieldId, const UnsignedInt object, const std::size_t offset) const {
-    CORRADE_ASSERT(object < _objectCount,
-        "Trade::SceneData::findFieldObjectOffset(): object" << object << "out of bounds for" << _objectCount << "objects", {});
+    CORRADE_ASSERT(object < _mappingBound,
+        "Trade::SceneData::findFieldObjectOffset(): object" << object << "out of bounds for" << _mappingBound << "objects", {});
     CORRADE_ASSERT(fieldId < _fields.size(),
         "Trade::SceneData::findFieldObjectOffset(): index" << fieldId << "out of range for" << _fields.size() << "fields", {});
 
@@ -898,8 +899,8 @@ Containers::Optional<std::size_t> SceneData::findFieldObjectOffset(const Unsigne
 }
 
 Containers::Optional<std::size_t> SceneData::findFieldObjectOffset(const SceneField fieldName, const UnsignedInt object, const std::size_t offset) const {
-    CORRADE_ASSERT(object < _objectCount,
-        "Trade::SceneData::findFieldObjectOffset(): object" << object << "out of bounds for" << _objectCount << "objects", {});
+    CORRADE_ASSERT(object < _mappingBound,
+        "Trade::SceneData::findFieldObjectOffset(): object" << object << "out of bounds for" << _mappingBound << "objects", {});
 
     const UnsignedInt fieldId = findFieldIdInternal(fieldName);
     CORRADE_ASSERT(fieldId != ~UnsignedInt{},
@@ -914,8 +915,8 @@ Containers::Optional<std::size_t> SceneData::findFieldObjectOffset(const SceneFi
 }
 
 std::size_t SceneData::fieldObjectOffset(const UnsignedInt fieldId, const UnsignedInt object, const std::size_t offset) const {
-    CORRADE_ASSERT(object < _objectCount,
-        "Trade::SceneData::fieldObjectOffset(): object" << object << "out of bounds for" << _objectCount << "objects", {});
+    CORRADE_ASSERT(object < _mappingBound,
+        "Trade::SceneData::fieldObjectOffset(): object" << object << "out of bounds for" << _mappingBound << "objects", {});
     CORRADE_ASSERT(fieldId < _fields.size(),
         "Trade::SceneData::fieldObjectOffset(): index" << fieldId << "out of range for" << _fields.size() << "fields", {});
 
@@ -930,8 +931,8 @@ std::size_t SceneData::fieldObjectOffset(const UnsignedInt fieldId, const Unsign
 }
 
 std::size_t SceneData::fieldObjectOffset(const SceneField fieldName, const UnsignedInt object, const std::size_t offset) const {
-    CORRADE_ASSERT(object < _objectCount,
-        "Trade::SceneData::fieldObjectOffset(): object" << object << "out of bounds for" << _objectCount << "objects", {});
+    CORRADE_ASSERT(object < _mappingBound,
+        "Trade::SceneData::fieldObjectOffset(): object" << object << "out of bounds for" << _mappingBound << "objects", {});
 
     const UnsignedInt fieldId = findFieldIdInternal(fieldName);
     CORRADE_ASSERT(fieldId != ~UnsignedInt{},
@@ -948,8 +949,8 @@ std::size_t SceneData::fieldObjectOffset(const SceneField fieldName, const Unsig
 }
 
 bool SceneData::hasFieldObject(const UnsignedInt fieldId, const UnsignedInt object) const {
-    CORRADE_ASSERT(object < _objectCount,
-        "Trade::SceneData::hasFieldObject(): object" << object << "out of bounds for" << _objectCount << "objects", {});
+    CORRADE_ASSERT(object < _mappingBound,
+        "Trade::SceneData::hasFieldObject(): object" << object << "out of bounds for" << _mappingBound << "objects", {});
     CORRADE_ASSERT(fieldId < _fields.size(),
         "Trade::SceneData::hasFieldObject(): index" << fieldId << "out of range for" << _fields.size() << "fields", {});
 
@@ -958,8 +959,8 @@ bool SceneData::hasFieldObject(const UnsignedInt fieldId, const UnsignedInt obje
 }
 
 bool SceneData::hasFieldObject(const SceneField fieldName, const UnsignedInt object) const {
-    CORRADE_ASSERT(object < _objectCount,
-        "Trade::SceneData::hasFieldObject(): object" << object << "out of bounds for" << _objectCount << "objects", {});
+    CORRADE_ASSERT(object < _mappingBound,
+        "Trade::SceneData::hasFieldObject(): object" << object << "out of bounds for" << _mappingBound << "objects", {});
 
     const UnsignedInt fieldId = findFieldIdInternal(fieldName);
     CORRADE_ASSERT(fieldId != ~UnsignedInt{},
@@ -987,26 +988,26 @@ UnsignedShort SceneData::fieldArraySize(const SceneField name) const {
     return _fields[fieldId]._fieldArraySize;
 }
 
-Containers::StridedArrayView2D<const char> SceneData::objects(const UnsignedInt fieldId) const {
+Containers::StridedArrayView2D<const char> SceneData::mapping(const UnsignedInt fieldId) const {
     CORRADE_ASSERT(fieldId < _fields.size(),
-        "Trade::SceneData::objects(): index" << fieldId << "out of range for" << _fields.size() << "fields", {});
+        "Trade::SceneData::mapping(): index" << fieldId << "out of range for" << _fields.size() << "fields", {});
     const SceneFieldData& field = _fields[fieldId];
-    /* Build a 2D view using information about object type size */
+    /* Build a 2D view using information about mapping type size */
     return Containers::arrayCast<2, const char>(
-        fieldDataObjectViewInternal(field),
-        sceneObjectTypeSize(field._objectType));
+        fieldDataMappingViewInternal(field),
+        sceneMappingTypeSize(field._mappingType));
 }
 
-Containers::StridedArrayView2D<char> SceneData::mutableObjects(const UnsignedInt fieldId) {
+Containers::StridedArrayView2D<char> SceneData::mutableMapping(const UnsignedInt fieldId) {
     CORRADE_ASSERT(_dataFlags & DataFlag::Mutable,
-        "Trade::SceneData::mutableObjects(): data not mutable", {});
+        "Trade::SceneData::mutableMapping(): data not mutable", {});
     CORRADE_ASSERT(fieldId < _fields.size(),
-        "Trade::SceneData::mutableObjects(): index" << fieldId << "out of range for" << _fields.size() << "fields", {});
+        "Trade::SceneData::mutableMapping(): index" << fieldId << "out of range for" << _fields.size() << "fields", {});
     const SceneFieldData& field = _fields[fieldId];
     /* Build a 2D view using information about attribute type size */
     const auto out = Containers::arrayCast<2, const char>(
-        fieldDataObjectViewInternal(field),
-        sceneObjectTypeSize(field._objectType));
+        fieldDataMappingViewInternal(field),
+        sceneMappingTypeSize(field._mappingType));
     /** @todo some arrayConstCast? UGH */
     return Containers::StridedArrayView2D<char>{
         /* The view size is there only for a size assert, we're pretty sure the
@@ -1015,25 +1016,25 @@ Containers::StridedArrayView2D<char> SceneData::mutableObjects(const UnsignedInt
         out.size(), out.stride()};
 }
 
-Containers::StridedArrayView2D<const char> SceneData::objects(const SceneField fieldName) const {
+Containers::StridedArrayView2D<const char> SceneData::mapping(const SceneField fieldName) const {
     const UnsignedInt fieldId = findFieldIdInternal(fieldName);
-    CORRADE_ASSERT(fieldId != ~UnsignedInt{}, "Trade::SceneData::objects(): field" << fieldName << "not found", {});
-    return objects(fieldId);
+    CORRADE_ASSERT(fieldId != ~UnsignedInt{}, "Trade::SceneData::mapping(): field" << fieldName << "not found", {});
+    return mapping(fieldId);
 }
 
-Containers::StridedArrayView2D<char> SceneData::mutableObjects(const SceneField fieldName) {
+Containers::StridedArrayView2D<char> SceneData::mutableMapping(const SceneField fieldName) {
     CORRADE_ASSERT(_dataFlags & DataFlag::Mutable,
-        "Trade::SceneData::mutableObjects(): data not mutable", {});
+        "Trade::SceneData::mutableMapping(): data not mutable", {});
     const UnsignedInt fieldId = findFieldIdInternal(fieldName);
-    CORRADE_ASSERT(fieldId != ~UnsignedInt{}, "Trade::SceneData::mutableObjects(): field" << fieldName << "not found", {});
-    return mutableObjects(fieldId);
+    CORRADE_ASSERT(fieldId != ~UnsignedInt{}, "Trade::SceneData::mutableMapping(): field" << fieldName << "not found", {});
+    return mutableMapping(fieldId);
 }
 
 Containers::StridedArrayView2D<const char> SceneData::field(const UnsignedInt id) const {
     CORRADE_ASSERT(id < _fields.size(),
         "Trade::SceneData::field(): index" << id << "out of range for" << _fields.size() << "fields", {});
     const SceneFieldData& field = _fields[id];
-    /* Build a 2D view using information about object type size */
+    /* Build a 2D view using information about mapping type size */
     return Containers::arrayCast<2, const char>(
         fieldDataFieldViewInternal(field),
         sceneFieldTypeSize(field._fieldType)*(field._fieldArraySize ? field._fieldArraySize : 1));
@@ -1073,74 +1074,74 @@ Containers::StridedArrayView2D<char> SceneData::mutableField(const SceneField na
     return mutableField(fieldId);
 }
 
-void SceneData::objectsIntoInternal(const UnsignedInt fieldId, const std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& destination) const {
+void SceneData::mappingIntoInternal(const UnsignedInt fieldId, const std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& destination) const {
     /* fieldId, offset and destination.size() is assumed to be in bounds,
        checked by the callers */
 
     const SceneFieldData& field = _fields[fieldId];
-    const Containers::StridedArrayView1D<const void> objectData = fieldDataObjectViewInternal(field, offset, destination.size());
+    const Containers::StridedArrayView1D<const void> mappingData = fieldDataMappingViewInternal(field, offset, destination.size());
     const auto destination1ui = Containers::arrayCast<2, UnsignedInt>(destination);
 
-    if(field._objectType == SceneObjectType::UnsignedInt)
-        Utility::copy(Containers::arrayCast<const UnsignedInt>(objectData), destination);
-    else if(field._objectType == SceneObjectType::UnsignedShort)
-        Math::castInto(Containers::arrayCast<2, const UnsignedShort>(objectData, 1), destination1ui);
-    else if(field._objectType == SceneObjectType::UnsignedByte)
-        Math::castInto(Containers::arrayCast<2, const UnsignedByte>(objectData, 1), destination1ui);
-    else if(field._objectType == SceneObjectType::UnsignedLong) {
-        Math::castInto(Containers::arrayCast<2, const UnsignedLong>(objectData, 1), destination1ui);
+    if(field._mappingType == SceneMappingType::UnsignedInt)
+        Utility::copy(Containers::arrayCast<const UnsignedInt>(mappingData), destination);
+    else if(field._mappingType == SceneMappingType::UnsignedShort)
+        Math::castInto(Containers::arrayCast<2, const UnsignedShort>(mappingData, 1), destination1ui);
+    else if(field._mappingType == SceneMappingType::UnsignedByte)
+        Math::castInto(Containers::arrayCast<2, const UnsignedByte>(mappingData, 1), destination1ui);
+    else if(field._mappingType == SceneMappingType::UnsignedLong) {
+        Math::castInto(Containers::arrayCast<2, const UnsignedLong>(mappingData, 1), destination1ui);
     } else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
 }
 
-void SceneData::objectsInto(const UnsignedInt fieldId, const Containers::StridedArrayView1D<UnsignedInt>& destination) const {
+void SceneData::mappingInto(const UnsignedInt fieldId, const Containers::StridedArrayView1D<UnsignedInt>& destination) const {
     CORRADE_ASSERT(fieldId < _fields.size(),
-        "Trade::SceneData::objectsInto(): index" << fieldId << "out of range for" << _fields.size() << "fields", );
+        "Trade::SceneData::mappingInto(): index" << fieldId << "out of range for" << _fields.size() << "fields", );
     CORRADE_ASSERT(destination.size() == _fields[fieldId]._size,
-        "Trade::SceneData::objectsInto(): expected a view with" << _fields[fieldId]._size << "elements but got" << destination.size(), );
-    objectsIntoInternal(fieldId, 0, destination);
+        "Trade::SceneData::mappingInto(): expected a view with" << _fields[fieldId]._size << "elements but got" << destination.size(), );
+    mappingIntoInternal(fieldId, 0, destination);
 }
 
-std::size_t SceneData::objectsInto(const UnsignedInt fieldId, const std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& destination) const {
+std::size_t SceneData::mappingInto(const UnsignedInt fieldId, const std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& destination) const {
     CORRADE_ASSERT(fieldId < _fields.size(),
-        "Trade::SceneData::objectsInto(): index" << fieldId << "out of range for" << _fields.size() << "fields", {});
+        "Trade::SceneData::mappingInto(): index" << fieldId << "out of range for" << _fields.size() << "fields", {});
     CORRADE_ASSERT(offset <= _fields[fieldId]._size,
-        "Trade::SceneData::objectsInto(): offset" << offset << "out of bounds for a field of size" << _fields[fieldId]._size, {});
+        "Trade::SceneData::mappingInto(): offset" << offset << "out of bounds for a field of size" << _fields[fieldId]._size, {});
     const std::size_t size = Math::min(destination.size(), std::size_t(_fields[fieldId]._size) - offset);
-    objectsIntoInternal(fieldId, offset, destination.prefix(size));
+    mappingIntoInternal(fieldId, offset, destination.prefix(size));
     return size;
 }
 
-Containers::Array<UnsignedInt> SceneData::objectsAsArray(const UnsignedInt fieldId) const {
+Containers::Array<UnsignedInt> SceneData::mappingAsArray(const UnsignedInt fieldId) const {
     CORRADE_ASSERT(fieldId < _fields.size(),
         /* Using the same message as in Into() to avoid too many redundant
            strings in the binary */
-        "Trade::SceneData::objectsInto(): index" << fieldId << "out of range for" << _fields.size() << "fields", {});
+        "Trade::SceneData::mappingInto(): index" << fieldId << "out of range for" << _fields.size() << "fields", {});
     Containers::Array<UnsignedInt> out{NoInit, std::size_t(_fields[fieldId]._size)};
-    objectsIntoInternal(fieldId, 0, out);
+    mappingIntoInternal(fieldId, 0, out);
     return out;
 }
 
-void SceneData::objectsInto(const SceneField name, const Containers::StridedArrayView1D<UnsignedInt>& destination) const {
+void SceneData::mappingInto(const SceneField name, const Containers::StridedArrayView1D<UnsignedInt>& destination) const {
     const UnsignedInt fieldId = findFieldIdInternal(name);
     CORRADE_ASSERT(fieldId != ~UnsignedInt{},
-        "Trade::SceneData::objectsInto(): field" << name << "not found", );
-    objectsInto(fieldId, destination);
+        "Trade::SceneData::mappingInto(): field" << name << "not found", );
+    mappingInto(fieldId, destination);
 }
 
-std::size_t SceneData::objectsInto(const SceneField name, std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& destination) const {
+std::size_t SceneData::mappingInto(const SceneField name, std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& destination) const {
     const UnsignedInt fieldId = findFieldIdInternal(name);
     CORRADE_ASSERT(fieldId != ~UnsignedInt{},
-        "Trade::SceneData::objectsInto(): field" << name << "not found", {});
-    return objectsInto(fieldId, offset, destination);
+        "Trade::SceneData::mappingInto(): field" << name << "not found", {});
+    return mappingInto(fieldId, offset, destination);
 }
 
-Containers::Array<UnsignedInt> SceneData::objectsAsArray(const SceneField name) const {
+Containers::Array<UnsignedInt> SceneData::mappingAsArray(const SceneField name) const {
     const UnsignedInt fieldId = findFieldIdInternal(name);
     CORRADE_ASSERT(fieldId != ~UnsignedInt{},
         /* Using the same message as in Into() to avoid too many redundant
            strings in the binary */
-        "Trade::SceneData::objectsInto(): field" << name << "not found", {});
-    return objectsAsArray(fieldId);
+        "Trade::SceneData::mappingInto(): field" << name << "not found", {});
+    return mappingAsArray(fieldId);
 }
 
 void SceneData::parentsIntoInternal(const UnsignedInt fieldId, const std::size_t offset, const Containers::StridedArrayView1D<Int>& destination) const {
@@ -1162,29 +1163,29 @@ void SceneData::parentsIntoInternal(const UnsignedInt fieldId, const std::size_t
     } else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
 }
 
-void SceneData::parentsInto(const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<Int>& fieldDestination) const {
+void SceneData::parentsInto(const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<Int>& fieldDestination) const {
     const UnsignedInt fieldId = findFieldIdInternal(SceneField::Parent);
     CORRADE_ASSERT(fieldId != ~UnsignedInt{},
         "Trade::SceneData::parentsInto(): field not found", );
-    CORRADE_ASSERT(!objectDestination || objectDestination.size() == _fields[fieldId]._size,
-        "Trade::SceneData::parentsInto(): expected object destination view either empty or with" << _fields[fieldId]._size << "elements but got" << objectDestination.size(), );
+    CORRADE_ASSERT(!mappingDestination || mappingDestination.size() == _fields[fieldId]._size,
+        "Trade::SceneData::parentsInto(): expected mapping destination view either empty or with" << _fields[fieldId]._size << "elements but got" << mappingDestination.size(), );
     CORRADE_ASSERT(!fieldDestination || fieldDestination.size() == _fields[fieldId]._size,
         "Trade::SceneData::parentsInto(): expected field destination view either empty or with" << _fields[fieldId]._size << "elements but got" << fieldDestination.size(), );
-    objectsIntoInternal(fieldId, 0, objectDestination);
+    mappingIntoInternal(fieldId, 0, mappingDestination);
     parentsIntoInternal(fieldId, 0, fieldDestination);
 }
 
-std::size_t SceneData::parentsInto(const std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<Int>& fieldDestination) const {
+std::size_t SceneData::parentsInto(const std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<Int>& fieldDestination) const {
     const UnsignedInt fieldId = findFieldIdInternal(SceneField::Parent);
     CORRADE_ASSERT(fieldId != ~UnsignedInt{},
         "Trade::SceneData::parentsInto(): field not found", {});
     const std::size_t fieldSize = _fields[fieldId]._size;
     CORRADE_ASSERT(offset <= fieldSize,
         "Trade::SceneData::parentsInto(): offset" << offset << "out of bounds for a field of size" << fieldSize, {});
-    CORRADE_ASSERT(!objectDestination != !fieldDestination|| objectDestination.size() == fieldDestination.size(),
-        "Trade::SceneData::parentsInto(): object and field destination views have different size," << objectDestination.size() << "vs" << fieldDestination.size(), {});
-    const std::size_t size = Math::min(Math::max(objectDestination.size(), fieldDestination.size()), fieldSize - offset);
-    if(objectDestination) objectsIntoInternal(fieldId, offset, objectDestination.prefix(size));
+    CORRADE_ASSERT(!mappingDestination != !fieldDestination|| mappingDestination.size() == fieldDestination.size(),
+        "Trade::SceneData::parentsInto(): mapping and field destination views have different size," << mappingDestination.size() << "vs" << fieldDestination.size(), {});
+    const std::size_t size = Math::min(Math::max(mappingDestination.size(), fieldDestination.size()), fieldSize - offset);
+    if(mappingDestination) mappingIntoInternal(fieldId, offset, mappingDestination.prefix(size));
     if(fieldDestination) parentsIntoInternal(fieldId, offset, fieldDestination.prefix(size));
     return size;
 }
@@ -1197,7 +1198,7 @@ Containers::Array<Containers::Pair<UnsignedInt, Int>> SceneData::parentsAsArray(
         "Trade::SceneData::parentsInto(): field not found", {});
     Containers::Array<Containers::Pair<UnsignedInt, Int>> out{NoInit, std::size_t(_fields[fieldId]._size)};
     /** @todo use slicing once Pair exposes members somehow */
-    objectsIntoInternal(fieldId, 0, {out, reinterpret_cast<UnsignedInt*>(reinterpret_cast<char*>(out.data())), out.size(), sizeof(decltype(out)::Type)});
+    mappingIntoInternal(fieldId, 0, {out, reinterpret_cast<UnsignedInt*>(reinterpret_cast<char*>(out.data())), out.size(), sizeof(decltype(out)::Type)});
     parentsIntoInternal(fieldId, 0, {out, reinterpret_cast<Int*>(reinterpret_cast<char*>(out.data()) + sizeof(UnsignedInt)), out.size(), sizeof(decltype(out)::Type)});
     return out;
 }
@@ -1368,20 +1369,20 @@ void SceneData::transformations2DIntoInternal(const UnsignedInt transformationFi
     } else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
 }
 
-void SceneData::transformations2DInto(const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<Matrix3>& fieldDestination) const {
+void SceneData::transformations2DInto(const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<Matrix3>& fieldDestination) const {
     UnsignedInt transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId;
     const UnsignedInt fieldWithObjectMapping = findTransformFields(transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId);
     CORRADE_ASSERT(fieldWithObjectMapping != ~UnsignedInt{},
         "Trade::SceneData::transformations2DInto(): no transformation-related field found", );
-    CORRADE_ASSERT(!objectDestination || objectDestination.size() == _fields[fieldWithObjectMapping]._size,
-        "Trade::SceneData::transformations2DInto(): expected object destination view either empty or with" << _fields[fieldWithObjectMapping]._size << "elements but got" << objectDestination.size(), );
+    CORRADE_ASSERT(!mappingDestination || mappingDestination.size() == _fields[fieldWithObjectMapping]._size,
+        "Trade::SceneData::transformations2DInto(): expected mapping destination view either empty or with" << _fields[fieldWithObjectMapping]._size << "elements but got" << mappingDestination.size(), );
     CORRADE_ASSERT(!fieldDestination || fieldDestination.size() == _fields[fieldWithObjectMapping]._size,
         "Trade::SceneData::transformations2DInto(): expected field destination view either empty or with" << _fields[fieldWithObjectMapping]._size << "elements but got" << fieldDestination.size(), );
-    objectsIntoInternal(fieldWithObjectMapping, 0, objectDestination);
+    mappingIntoInternal(fieldWithObjectMapping, 0, mappingDestination);
     transformations2DIntoInternal(transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId, 0, fieldDestination);
 }
 
-std::size_t SceneData::transformations2DInto(const std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<Matrix3>& fieldDestination) const {
+std::size_t SceneData::transformations2DInto(const std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<Matrix3>& fieldDestination) const {
     UnsignedInt transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId;
     const UnsignedInt fieldWithObjectMapping = findTransformFields(transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId);
     CORRADE_ASSERT(fieldWithObjectMapping != ~UnsignedInt{},
@@ -1389,10 +1390,10 @@ std::size_t SceneData::transformations2DInto(const std::size_t offset, const Con
     const std::size_t fieldSize = _fields[fieldWithObjectMapping]._size;
     CORRADE_ASSERT(offset <= fieldSize,
         "Trade::SceneData::transformations2DInto(): offset" << offset << "out of bounds for a field of size" << fieldSize, {});
-    CORRADE_ASSERT(!objectDestination != !fieldDestination|| objectDestination.size() == fieldDestination.size(),
-        "Trade::SceneData::transformations2DInto(): object and field destination views have different size," << objectDestination.size() << "vs" << fieldDestination.size(), {});
-    const std::size_t size = Math::min(Math::max(objectDestination.size(), fieldDestination.size()), fieldSize - offset);
-    if(objectDestination) objectsIntoInternal(fieldWithObjectMapping, offset, objectDestination.prefix(size));
+    CORRADE_ASSERT(!mappingDestination != !fieldDestination|| mappingDestination.size() == fieldDestination.size(),
+        "Trade::SceneData::transformations2DInto(): mapping and field destination views have different size," << mappingDestination.size() << "vs" << fieldDestination.size(), {});
+    const std::size_t size = Math::min(Math::max(mappingDestination.size(), fieldDestination.size()), fieldSize - offset);
+    if(mappingDestination) mappingIntoInternal(fieldWithObjectMapping, offset, mappingDestination.prefix(size));
     if(fieldDestination) transformations2DIntoInternal(transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId, offset, fieldDestination.prefix(size));
     return size;
 }
@@ -1406,7 +1407,7 @@ Containers::Array<Containers::Pair<UnsignedInt, Matrix3>> SceneData::transformat
         "Trade::SceneData::transformations2DInto(): no transformation-related field found", {});
     Containers::Array<Containers::Pair<UnsignedInt, Matrix3>> out{NoInit, std::size_t(_fields[fieldWithObjectMapping]._size)};
     /** @todo use slicing once Pair exposes members somehow */
-    objectsIntoInternal(fieldWithObjectMapping, 0, {out, reinterpret_cast<UnsignedInt*>(reinterpret_cast<char*>(out.data())), out.size(), sizeof(decltype(out)::Type)});
+    mappingIntoInternal(fieldWithObjectMapping, 0, {out, reinterpret_cast<UnsignedInt*>(reinterpret_cast<char*>(out.data())), out.size(), sizeof(decltype(out)::Type)});
     transformations2DIntoInternal(transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId, 0, {out, reinterpret_cast<Matrix3*>(reinterpret_cast<char*>(out.data()) + sizeof(UnsignedInt)), out.size(), sizeof(decltype(out)::Type)});
     return out;
 }
@@ -1474,24 +1475,24 @@ void SceneData::translationsRotationsScalings2DIntoInternal(const UnsignedInt tr
     }
 }
 
-void SceneData::translationsRotationsScalings2DInto(const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<Vector2>& translationDestination, const Containers::StridedArrayView1D<Complex>& rotationDestination, const Containers::StridedArrayView1D<Vector2>& scalingDestination) const {
+void SceneData::translationsRotationsScalings2DInto(const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<Vector2>& translationDestination, const Containers::StridedArrayView1D<Complex>& rotationDestination, const Containers::StridedArrayView1D<Vector2>& scalingDestination) const {
     UnsignedInt translationFieldId, rotationFieldId, scalingFieldId;
     const UnsignedInt fieldWithObjectMapping = findTranslationRotationScalingFields(translationFieldId, rotationFieldId, scalingFieldId);
     CORRADE_ASSERT(fieldWithObjectMapping != ~UnsignedInt{},
         "Trade::SceneData::translationsRotationsScalings2DInto(): no transformation-related field found", );
-    CORRADE_ASSERT(!objectDestination || objectDestination.size() == _fields[fieldWithObjectMapping]._size,
-        "Trade::SceneData::translationsRotationsScalings2DInto(): expected object destination view either empty or with" << _fields[fieldWithObjectMapping]._size << "elements but got" << objectDestination.size(), );
+    CORRADE_ASSERT(!mappingDestination || mappingDestination.size() == _fields[fieldWithObjectMapping]._size,
+        "Trade::SceneData::translationsRotationsScalings2DInto(): expected mapping destination view either empty or with" << _fields[fieldWithObjectMapping]._size << "elements but got" << mappingDestination.size(), );
     CORRADE_ASSERT(!translationDestination || translationDestination.size() == _fields[fieldWithObjectMapping]._size,
         "Trade::SceneData::translationsRotationsScalings2DInto(): expected translation destination view either empty or with" << _fields[fieldWithObjectMapping]._size << "elements but got" << translationDestination.size(), );
     CORRADE_ASSERT(!rotationDestination || rotationDestination.size() == _fields[fieldWithObjectMapping]._size,
         "Trade::SceneData::translationsRotationsScalings2DInto(): expected rotation destination view either empty or with" << _fields[fieldWithObjectMapping]._size << "elements but got" << rotationDestination.size(), );
     CORRADE_ASSERT(!scalingDestination || scalingDestination.size() == _fields[fieldWithObjectMapping]._size,
         "Trade::SceneData::translationsRotationsScalings2DInto(): expected scaling destination view either empty or with" << _fields[fieldWithObjectMapping]._size << "elements but got" << scalingDestination.size(), );
-    objectsIntoInternal(fieldWithObjectMapping, 0, objectDestination);
+    mappingIntoInternal(fieldWithObjectMapping, 0, mappingDestination);
     translationsRotationsScalings2DIntoInternal(translationFieldId, rotationFieldId, scalingFieldId, 0, translationDestination, rotationDestination, scalingDestination);
 }
 
-std::size_t SceneData::translationsRotationsScalings2DInto(const std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<Vector2>& translationDestination, const Containers::StridedArrayView1D<Complex>& rotationDestination, const Containers::StridedArrayView1D<Vector2>& scalingDestination) const {
+std::size_t SceneData::translationsRotationsScalings2DInto(const std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<Vector2>& translationDestination, const Containers::StridedArrayView1D<Complex>& rotationDestination, const Containers::StridedArrayView1D<Vector2>& scalingDestination) const {
     UnsignedInt translationFieldId, rotationFieldId, scalingFieldId;
     const UnsignedInt fieldWithObjectMapping = findTranslationRotationScalingFields(translationFieldId, rotationFieldId, scalingFieldId);
     CORRADE_ASSERT(fieldWithObjectMapping != ~UnsignedInt{},
@@ -1499,20 +1500,20 @@ std::size_t SceneData::translationsRotationsScalings2DInto(const std::size_t off
     const std::size_t fieldSize = _fields[fieldWithObjectMapping]._size;
     CORRADE_ASSERT(offset <= fieldSize,
         "Trade::SceneData::translationsRotationsScalings2DInto(): offset" << offset << "out of bounds for a field of size" << fieldSize, {});
-    CORRADE_ASSERT(!objectDestination != !translationDestination || objectDestination.size() == translationDestination.size(),
-        "Trade::SceneData::translationsRotationsScalings2DInto(): object and translation destination views have different size," << objectDestination.size() << "vs" << translationDestination.size(), {});
-    CORRADE_ASSERT(!objectDestination != !rotationDestination || objectDestination.size() == rotationDestination.size(),
-        "Trade::SceneData::translationsRotationsScalings2DInto(): object and rotation destination views have different size," << objectDestination.size() << "vs" << rotationDestination.size(), {});
-    CORRADE_ASSERT(!objectDestination != !scalingDestination || objectDestination.size() == scalingDestination.size(),
-        "Trade::SceneData::translationsRotationsScalings2DInto(): object and scaling destination views have different size," << objectDestination.size() << "vs" << scalingDestination.size(), {});
+    CORRADE_ASSERT(!mappingDestination != !translationDestination || mappingDestination.size() == translationDestination.size(),
+        "Trade::SceneData::translationsRotationsScalings2DInto(): mapping and translation destination views have different size," << mappingDestination.size() << "vs" << translationDestination.size(), {});
+    CORRADE_ASSERT(!mappingDestination != !rotationDestination || mappingDestination.size() == rotationDestination.size(),
+        "Trade::SceneData::translationsRotationsScalings2DInto(): mapping and rotation destination views have different size," << mappingDestination.size() << "vs" << rotationDestination.size(), {});
+    CORRADE_ASSERT(!mappingDestination != !scalingDestination || mappingDestination.size() == scalingDestination.size(),
+        "Trade::SceneData::translationsRotationsScalings2DInto(): mapping and scaling destination views have different size," << mappingDestination.size() << "vs" << scalingDestination.size(), {});
     CORRADE_ASSERT(!translationDestination != !rotationDestination || translationDestination.size() == rotationDestination.size(),
         "Trade::SceneData::translationsRotationsScalings2DInto(): translation and rotation destination views have different size," << translationDestination.size() << "vs" << rotationDestination.size(), {});
     CORRADE_ASSERT(!translationDestination != !scalingDestination || translationDestination.size() == scalingDestination.size(),
         "Trade::SceneData::translationsRotationsScalings2DInto(): translation and scaling destination views have different size," << translationDestination.size() << "vs" << scalingDestination.size(), {});
     CORRADE_ASSERT(!rotationDestination != !scalingDestination || rotationDestination.size() == scalingDestination.size(),
         "Trade::SceneData::translationsRotationsScalings2DInto(): rotation and scaling destination views have different size," << rotationDestination.size() << "vs" << scalingDestination.size(), {});
-    const std::size_t size = Math::min(Math::max({objectDestination.size(), translationDestination.size(), rotationDestination.size(), scalingDestination.size()}), fieldSize - offset);
-    if(objectDestination) objectsIntoInternal(fieldWithObjectMapping, offset, objectDestination.prefix(size));
+    const std::size_t size = Math::min(Math::max({mappingDestination.size(), translationDestination.size(), rotationDestination.size(), scalingDestination.size()}), fieldSize - offset);
+    if(mappingDestination) mappingIntoInternal(fieldWithObjectMapping, offset, mappingDestination.prefix(size));
     translationsRotationsScalings2DIntoInternal(translationFieldId, rotationFieldId, scalingFieldId, offset,
         translationDestination ? translationDestination.prefix(size) : nullptr,
         rotationDestination ? rotationDestination.prefix(size) : nullptr,
@@ -1529,7 +1530,7 @@ Containers::Array<Containers::Pair<UnsignedInt, Containers::Triple<Vector2, Comp
         "Trade::SceneData::translationsRotationsScalings2DInto(): no transformation-related field found", {});
     Containers::Array<Containers::Pair<UnsignedInt, Containers::Triple<Vector2, Complex, Vector2>>> out{NoInit, std::size_t(_fields[fieldWithObjectMapping]._size)};
     /** @todo use slicing once Triple exposes members somehow */
-    objectsIntoInternal(fieldWithObjectMapping, 0, {out, reinterpret_cast<UnsignedInt*>(reinterpret_cast<char*>(out.data())), out.size(), sizeof(decltype(out)::Type)});
+    mappingIntoInternal(fieldWithObjectMapping, 0, {out, reinterpret_cast<UnsignedInt*>(reinterpret_cast<char*>(out.data())), out.size(), sizeof(decltype(out)::Type)});
     const Containers::StridedArrayView1D<Vector2> translationsOut{out, reinterpret_cast<Vector2*>(reinterpret_cast<char*>(out.data()) + sizeof(UnsignedInt)), out.size(), sizeof(decltype(out)::Type)};
     const Containers::StridedArrayView1D<Complex> rotationsOut{out, reinterpret_cast<Complex*>(reinterpret_cast<char*>(out.data()) + sizeof(UnsignedInt) + sizeof(Vector2)), out.size(), sizeof(decltype(out)::Type)};
     const Containers::StridedArrayView1D<Vector2> scalingsOut{out, reinterpret_cast<Vector2*>(reinterpret_cast<char*>(out.data()) + sizeof(UnsignedInt) + sizeof(Vector2) + sizeof(Complex)), out.size(), sizeof(decltype(out)::Type)};
@@ -1613,20 +1614,20 @@ void SceneData::transformations3DIntoInternal(const UnsignedInt transformationFi
     } else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
 }
 
-void SceneData::transformations3DInto(const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<Matrix4>& fieldDestination) const {
+void SceneData::transformations3DInto(const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<Matrix4>& fieldDestination) const {
     UnsignedInt transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId;
     const std::size_t fieldWithObjectMapping = findTransformFields(transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId);
     CORRADE_ASSERT(fieldWithObjectMapping != ~UnsignedInt{},
         "Trade::SceneData::transformations3DInto(): no transformation-related field found", );
-    CORRADE_ASSERT(!objectDestination || objectDestination.size() == _fields[fieldWithObjectMapping]._size,
-        "Trade::SceneData::transformations3DInto(): expected object destination view either empty or with" << _fields[fieldWithObjectMapping]._size << "elements but got" << objectDestination.size(), );
+    CORRADE_ASSERT(!mappingDestination || mappingDestination.size() == _fields[fieldWithObjectMapping]._size,
+        "Trade::SceneData::transformations3DInto(): expected mapping destination view either empty or with" << _fields[fieldWithObjectMapping]._size << "elements but got" << mappingDestination.size(), );
     CORRADE_ASSERT(!fieldDestination || fieldDestination.size() == _fields[fieldWithObjectMapping]._size,
         "Trade::SceneData::transformations3DInto(): expected field destination view either empty or with" << _fields[fieldWithObjectMapping]._size << "elements but got" << fieldDestination.size(), );
-    objectsIntoInternal(fieldWithObjectMapping, 0, objectDestination);
+    mappingIntoInternal(fieldWithObjectMapping, 0, mappingDestination);
     transformations3DIntoInternal(transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId, 0, fieldDestination);
 }
 
-std::size_t SceneData::transformations3DInto(const std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<Matrix4>& fieldDestination) const {
+std::size_t SceneData::transformations3DInto(const std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<Matrix4>& fieldDestination) const {
     UnsignedInt transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId;
     const UnsignedInt fieldWithObjectMapping = findTransformFields(transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId);
     CORRADE_ASSERT(fieldWithObjectMapping != ~UnsignedInt{},
@@ -1634,10 +1635,10 @@ std::size_t SceneData::transformations3DInto(const std::size_t offset, const Con
     const std::size_t fieldSize = _fields[fieldWithObjectMapping]._size;
     CORRADE_ASSERT(offset <= fieldSize,
         "Trade::SceneData::transformations3DInto(): offset" << offset << "out of bounds for a field of size" << fieldSize, {});
-    CORRADE_ASSERT(!objectDestination != !fieldDestination|| objectDestination.size() == fieldDestination.size(),
-        "Trade::SceneData::transformations3DInto(): object and field destination views have different size," << objectDestination.size() << "vs" << fieldDestination.size(), {});
-    const std::size_t size = Math::min(Math::max(objectDestination.size(), fieldDestination.size()), fieldSize - offset);
-    if(objectDestination) objectsIntoInternal(fieldWithObjectMapping, offset, objectDestination.prefix(size));
+    CORRADE_ASSERT(!mappingDestination != !fieldDestination|| mappingDestination.size() == fieldDestination.size(),
+        "Trade::SceneData::transformations3DInto(): mapping and field destination views have different size," << mappingDestination.size() << "vs" << fieldDestination.size(), {});
+    const std::size_t size = Math::min(Math::max(mappingDestination.size(), fieldDestination.size()), fieldSize - offset);
+    if(mappingDestination) mappingIntoInternal(fieldWithObjectMapping, offset, mappingDestination.prefix(size));
     if(fieldDestination) transformations3DIntoInternal(transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId, offset, fieldDestination.prefix(size));
     return size;
 }
@@ -1651,7 +1652,7 @@ Containers::Array<Containers::Pair<UnsignedInt, Matrix4>> SceneData::transformat
         "Trade::SceneData::transformations3DInto(): no transformation-related field found", {});
     Containers::Array<Containers::Pair<UnsignedInt, Matrix4>> out{NoInit, std::size_t(_fields[fieldWithObjectMapping]._size)};
     /** @todo use slicing once Pair exposes members somehow */
-    objectsIntoInternal(fieldWithObjectMapping, 0, {out, reinterpret_cast<UnsignedInt*>(reinterpret_cast<char*>(out.data())), out.size(), sizeof(decltype(out)::Type)});
+    mappingIntoInternal(fieldWithObjectMapping, 0, {out, reinterpret_cast<UnsignedInt*>(reinterpret_cast<char*>(out.data())), out.size(), sizeof(decltype(out)::Type)});
     transformations3DIntoInternal(transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId, 0, {out, reinterpret_cast<Matrix4*>(reinterpret_cast<char*>(out.data()) + sizeof(UnsignedInt)), out.size(), sizeof(decltype(out)::Type)});
     return out;
 }
@@ -1719,24 +1720,24 @@ void SceneData::translationsRotationsScalings3DIntoInternal(const UnsignedInt tr
     }
 }
 
-void SceneData::translationsRotationsScalings3DInto(const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<Vector3>& translationDestination, const Containers::StridedArrayView1D<Quaternion>& rotationDestination, const Containers::StridedArrayView1D<Vector3>& scalingDestination) const {
+void SceneData::translationsRotationsScalings3DInto(const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<Vector3>& translationDestination, const Containers::StridedArrayView1D<Quaternion>& rotationDestination, const Containers::StridedArrayView1D<Vector3>& scalingDestination) const {
     UnsignedInt translationFieldId, rotationFieldId, scalingFieldId;
     const UnsignedInt fieldWithObjectMapping = findTranslationRotationScalingFields(translationFieldId, rotationFieldId, scalingFieldId);
     CORRADE_ASSERT(fieldWithObjectMapping != ~UnsignedInt{},
         "Trade::SceneData::translationsRotationsScalings3DInto(): no transformation-related field found", );
-    CORRADE_ASSERT(!objectDestination || objectDestination.size() == _fields[fieldWithObjectMapping]._size,
-        "Trade::SceneData::translationsRotationsScalings3DInto(): expected object destination view either empty or with" << _fields[fieldWithObjectMapping]._size << "elements but got" << objectDestination.size(), );
+    CORRADE_ASSERT(!mappingDestination || mappingDestination.size() == _fields[fieldWithObjectMapping]._size,
+        "Trade::SceneData::translationsRotationsScalings3DInto(): expected mapping destination view either empty or with" << _fields[fieldWithObjectMapping]._size << "elements but got" << mappingDestination.size(), );
     CORRADE_ASSERT(!translationDestination || translationDestination.size() == _fields[fieldWithObjectMapping]._size,
         "Trade::SceneData::translationsRotationsScalings3DInto(): expected translation destination view either empty or with" << _fields[fieldWithObjectMapping]._size << "elements but got" << translationDestination.size(), );
     CORRADE_ASSERT(!rotationDestination || rotationDestination.size() == _fields[fieldWithObjectMapping]._size,
         "Trade::SceneData::translationsRotationsScalings3DInto(): expected rotation destination view either empty or with" << _fields[fieldWithObjectMapping]._size << "elements but got" << rotationDestination.size(), );
     CORRADE_ASSERT(!scalingDestination || scalingDestination.size() == _fields[fieldWithObjectMapping]._size,
         "Trade::SceneData::translationsRotationsScalings3DInto(): expected scaling destination view either empty or with" << _fields[fieldWithObjectMapping]._size << "elements but got" << scalingDestination.size(), );
-    objectsIntoInternal(fieldWithObjectMapping, 0, objectDestination);
+    mappingIntoInternal(fieldWithObjectMapping, 0, mappingDestination);
     translationsRotationsScalings3DIntoInternal(translationFieldId, rotationFieldId, scalingFieldId, 0, translationDestination, rotationDestination, scalingDestination);
 }
 
-std::size_t SceneData::translationsRotationsScalings3DInto(const std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<Vector3>& translationDestination, const Containers::StridedArrayView1D<Quaternion>& rotationDestination, const Containers::StridedArrayView1D<Vector3>& scalingDestination) const {
+std::size_t SceneData::translationsRotationsScalings3DInto(const std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<Vector3>& translationDestination, const Containers::StridedArrayView1D<Quaternion>& rotationDestination, const Containers::StridedArrayView1D<Vector3>& scalingDestination) const {
     UnsignedInt translationFieldId, rotationFieldId, scalingFieldId;
     const UnsignedInt fieldWithObjectMapping = findTranslationRotationScalingFields(translationFieldId, rotationFieldId, scalingFieldId);
     CORRADE_ASSERT(fieldWithObjectMapping != ~UnsignedInt{},
@@ -1744,20 +1745,20 @@ std::size_t SceneData::translationsRotationsScalings3DInto(const std::size_t off
     const std::size_t fieldSize = _fields[fieldWithObjectMapping]._size;
     CORRADE_ASSERT(offset <= fieldSize,
         "Trade::SceneData::translationsRotationsScalings3DInto(): offset" << offset << "out of bounds for a field of size" << fieldSize, {});
-    CORRADE_ASSERT(!objectDestination != !translationDestination || objectDestination.size() == translationDestination.size(),
-        "Trade::SceneData::translationsRotationsScalings3DInto(): object and translation destination views have different size," << objectDestination.size() << "vs" << translationDestination.size(), {});
-    CORRADE_ASSERT(!objectDestination != !rotationDestination || objectDestination.size() == rotationDestination.size(),
-        "Trade::SceneData::translationsRotationsScalings3DInto(): object and rotation destination views have different size," << objectDestination.size() << "vs" << rotationDestination.size(), {});
-    CORRADE_ASSERT(!objectDestination != !scalingDestination || objectDestination.size() == scalingDestination.size(),
-        "Trade::SceneData::translationsRotationsScalings3DInto(): object and scaling destination views have different size," << objectDestination.size() << "vs" << scalingDestination.size(), {});
+    CORRADE_ASSERT(!mappingDestination != !translationDestination || mappingDestination.size() == translationDestination.size(),
+        "Trade::SceneData::translationsRotationsScalings3DInto(): mapping and translation destination views have different size," << mappingDestination.size() << "vs" << translationDestination.size(), {});
+    CORRADE_ASSERT(!mappingDestination != !rotationDestination || mappingDestination.size() == rotationDestination.size(),
+        "Trade::SceneData::translationsRotationsScalings3DInto(): mapping and rotation destination views have different size," << mappingDestination.size() << "vs" << rotationDestination.size(), {});
+    CORRADE_ASSERT(!mappingDestination != !scalingDestination || mappingDestination.size() == scalingDestination.size(),
+        "Trade::SceneData::translationsRotationsScalings3DInto(): mapping and scaling destination views have different size," << mappingDestination.size() << "vs" << scalingDestination.size(), {});
     CORRADE_ASSERT(!translationDestination != !rotationDestination || translationDestination.size() == rotationDestination.size(),
         "Trade::SceneData::translationsRotationsScalings3DInto(): translation and rotation destination views have different size," << translationDestination.size() << "vs" << rotationDestination.size(), {});
     CORRADE_ASSERT(!translationDestination != !scalingDestination || translationDestination.size() == scalingDestination.size(),
         "Trade::SceneData::translationsRotationsScalings3DInto(): translation and scaling destination views have different size," << translationDestination.size() << "vs" << scalingDestination.size(), {});
     CORRADE_ASSERT(!rotationDestination != !scalingDestination || rotationDestination.size() == scalingDestination.size(),
         "Trade::SceneData::translationsRotationsScalings3DInto(): rotation and scaling destination views have different size," << rotationDestination.size() << "vs" << scalingDestination.size(), {});
-    const std::size_t size = Math::min(Math::max({objectDestination.size(), translationDestination.size(), rotationDestination.size(), scalingDestination.size()}), fieldSize - offset);
-    if(objectDestination) objectsIntoInternal(fieldWithObjectMapping, offset, objectDestination.prefix(size));
+    const std::size_t size = Math::min(Math::max({mappingDestination.size(), translationDestination.size(), rotationDestination.size(), scalingDestination.size()}), fieldSize - offset);
+    if(mappingDestination) mappingIntoInternal(fieldWithObjectMapping, offset, mappingDestination.prefix(size));
     translationsRotationsScalings3DIntoInternal(translationFieldId, rotationFieldId, scalingFieldId, offset,
         translationDestination ? translationDestination.prefix(size) : nullptr,
         rotationDestination ? rotationDestination.prefix(size) : nullptr,
@@ -1774,7 +1775,7 @@ Containers::Array<Containers::Pair<UnsignedInt, Containers::Triple<Vector3, Quat
         "Trade::SceneData::translationsRotationsScalings3DInto(): no transformation-related field found", {});
     Containers::Array<Containers::Pair<UnsignedInt, Containers::Triple<Vector3, Quaternion, Vector3>>> out{NoInit, std::size_t(_fields[fieldWithObjectMapping]._size)};
     /** @todo use slicing once Triple exposes members somehow */
-    objectsIntoInternal(fieldWithObjectMapping, 0, {out, reinterpret_cast<UnsignedInt*>(reinterpret_cast<char*>(out.data())), out.size(), sizeof(decltype(out)::Type)});
+    mappingIntoInternal(fieldWithObjectMapping, 0, {out, reinterpret_cast<UnsignedInt*>(reinterpret_cast<char*>(out.data())), out.size(), sizeof(decltype(out)::Type)});
     const Containers::StridedArrayView1D<Vector3> translationsOut{out, reinterpret_cast<Vector3*>(reinterpret_cast<char*>(out.data()) + sizeof(UnsignedInt)), out.size(), sizeof(decltype(out)::Type)};
     const Containers::StridedArrayView1D<Quaternion> rotationsOut{out, reinterpret_cast<Quaternion*>(reinterpret_cast<char*>(out.data()) + sizeof(UnsignedInt) + sizeof(Vector3)), out.size(), sizeof(decltype(out)::Type)};
     const Containers::StridedArrayView1D<Vector3> scalingsOut{out, reinterpret_cast<Vector3*>(reinterpret_cast<char*>(out.data()) + sizeof(UnsignedInt) + sizeof(Vector3) + sizeof(Quaternion)), out.size(), sizeof(decltype(out)::Type)};
@@ -1819,7 +1820,7 @@ void SceneData::indexFieldIntoInternal(const UnsignedInt fieldId, const std::siz
 Containers::Array<Containers::Pair<UnsignedInt, UnsignedInt>> SceneData::unsignedIndexFieldAsArrayInternal(const UnsignedInt fieldId) const {
     Containers::Array<Containers::Pair<UnsignedInt, UnsignedInt>> out{NoInit, std::size_t(_fields[fieldId]._size)};
     /** @todo use slicing once Pair exposes members somehow */
-    objectsIntoInternal(fieldId, 0, {out, reinterpret_cast<UnsignedInt*>(reinterpret_cast<char*>(out.data())), out.size(), sizeof(decltype(out)::Type)});
+    mappingIntoInternal(fieldId, 0, {out, reinterpret_cast<UnsignedInt*>(reinterpret_cast<char*>(out.data())), out.size(), sizeof(decltype(out)::Type)});
     unsignedIndexFieldIntoInternal(fieldId, 0, {out, reinterpret_cast<UnsignedInt*>(reinterpret_cast<char*>(out.data()) + sizeof(UnsignedInt)), out.size(), sizeof(decltype(out)::Type)});
     return out;
 }
@@ -1843,35 +1844,35 @@ void SceneData::meshesMaterialsIntoInternal(const UnsignedInt fieldId, const std
     }
 }
 
-void SceneData::meshesMaterialsInto(const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<UnsignedInt>& meshDestination, const Containers::StridedArrayView1D<Int>& meshMaterialDestination) const {
+void SceneData::meshesMaterialsInto(const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<UnsignedInt>& meshDestination, const Containers::StridedArrayView1D<Int>& meshMaterialDestination) const {
     const UnsignedInt fieldId = findFieldIdInternal(SceneField::Mesh);
     CORRADE_ASSERT(fieldId != ~UnsignedInt{},
         "Trade::SceneData::meshesMaterialsInto(): field" << SceneField::Mesh << "not found", );
-    CORRADE_ASSERT(!objectDestination || objectDestination.size() == _fields[fieldId]._size,
-        "Trade::SceneData::meshesMaterialsInto(): expected object destination view either empty or with" << _fields[fieldId]._size << "elements but got" << objectDestination.size(), );
+    CORRADE_ASSERT(!mappingDestination || mappingDestination.size() == _fields[fieldId]._size,
+        "Trade::SceneData::meshesMaterialsInto(): expected mapping destination view either empty or with" << _fields[fieldId]._size << "elements but got" << mappingDestination.size(), );
     CORRADE_ASSERT(!meshDestination || meshDestination.size() == _fields[fieldId]._size,
         "Trade::SceneData::meshesMaterialsInto(): expected mesh destination view either empty or with" << _fields[fieldId]._size << "elements but got" << meshDestination.size(), );
     CORRADE_ASSERT(!meshMaterialDestination || meshMaterialDestination.size() == _fields[fieldId]._size,
         "Trade::SceneData::meshesMaterialsInto(): expected mesh material destination view either empty or with" << _fields[fieldId]._size << "elements but got" << meshMaterialDestination.size(), );
-    objectsIntoInternal(fieldId, 0, objectDestination);
+    mappingIntoInternal(fieldId, 0, mappingDestination);
     meshesMaterialsIntoInternal(fieldId, 0, meshDestination, meshMaterialDestination);
 }
 
-std::size_t SceneData::meshesMaterialsInto(const std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<UnsignedInt>& meshDestination, const Containers::StridedArrayView1D<Int>& meshMaterialDestination) const {
+std::size_t SceneData::meshesMaterialsInto(const std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<UnsignedInt>& meshDestination, const Containers::StridedArrayView1D<Int>& meshMaterialDestination) const {
     const UnsignedInt fieldId = findFieldIdInternal(SceneField::Mesh);
     CORRADE_ASSERT(fieldId != ~UnsignedInt{},
         "Trade::SceneData::meshesMaterialsInto(): field" << SceneField::Mesh << "not found", {});
     const std::size_t fieldSize = _fields[fieldId]._size;
     CORRADE_ASSERT(offset <= fieldSize,
         "Trade::SceneData::meshesMaterialsInto(): offset" << offset << "out of bounds for a field of size" << fieldSize, {});
-    CORRADE_ASSERT(!objectDestination != !meshDestination || objectDestination.size() == meshDestination.size(),
-        "Trade::SceneData::meshesMaterialsInto(): object and mesh destination views have different size," << objectDestination.size() << "vs" << meshDestination.size(), {});
-    CORRADE_ASSERT(!objectDestination != !meshMaterialDestination || objectDestination.size() == meshMaterialDestination.size(),
-        "Trade::SceneData::meshesMaterialsInto(): object and mesh material destination views have different size," << objectDestination.size() << "vs" << meshMaterialDestination.size(), {});
+    CORRADE_ASSERT(!mappingDestination != !meshDestination || mappingDestination.size() == meshDestination.size(),
+        "Trade::SceneData::meshesMaterialsInto(): mapping and mesh destination views have different size," << mappingDestination.size() << "vs" << meshDestination.size(), {});
+    CORRADE_ASSERT(!mappingDestination != !meshMaterialDestination || mappingDestination.size() == meshMaterialDestination.size(),
+        "Trade::SceneData::meshesMaterialsInto(): mapping and mesh material destination views have different size," << mappingDestination.size() << "vs" << meshMaterialDestination.size(), {});
     CORRADE_ASSERT(!meshDestination != !meshMaterialDestination || meshMaterialDestination.size() == meshDestination.size(),
         "Trade::SceneData::meshesMaterialsInto(): mesh and mesh material destination views have different size," << meshDestination.size() << "vs" << meshMaterialDestination.size(), {});
-    const std::size_t size = Math::min(Math::max({objectDestination.size(), meshDestination.size(), meshMaterialDestination.size()}), fieldSize - offset);
-    if(objectDestination) objectsIntoInternal(fieldId, offset, objectDestination.prefix(size));
+    const std::size_t size = Math::min(Math::max({mappingDestination.size(), meshDestination.size(), meshMaterialDestination.size()}), fieldSize - offset);
+    if(mappingDestination) mappingIntoInternal(fieldId, offset, mappingDestination.prefix(size));
     meshesMaterialsIntoInternal(fieldId, offset,
         meshDestination ? meshDestination.prefix(size) : nullptr,
         meshMaterialDestination ? meshMaterialDestination.prefix(size) : nullptr);
@@ -1886,36 +1887,36 @@ Containers::Array<Containers::Pair<UnsignedInt, Containers::Pair<UnsignedInt, In
         "Trade::SceneData::meshesMaterialsInto(): field" << SceneField::Mesh << "not found", {});
     Containers::Array<Containers::Pair<UnsignedInt, Containers::Pair<UnsignedInt, Int>>> out{NoInit, std::size_t(_fields[fieldId]._size)};
     /** @todo use slicing once Pair exposes members somehow */
-    objectsIntoInternal(fieldId, 0, {out, reinterpret_cast<UnsignedInt*>(reinterpret_cast<char*>(out.data())), out.size(), sizeof(decltype(out)::Type)});
+    mappingIntoInternal(fieldId, 0, {out, reinterpret_cast<UnsignedInt*>(reinterpret_cast<char*>(out.data())), out.size(), sizeof(decltype(out)::Type)});
     const Containers::StridedArrayView1D<UnsignedInt> meshesOut{out, reinterpret_cast<UnsignedInt*>(reinterpret_cast<char*>(out.data()) + sizeof(UnsignedInt)), out.size(), sizeof(decltype(out)::Type)};
     const Containers::StridedArrayView1D<Int> meshMaterialsOut{out, reinterpret_cast<Int*>(reinterpret_cast<char*>(out.data()) + sizeof(UnsignedInt) + sizeof(UnsignedInt)), out.size(), sizeof(decltype(out)::Type)};
     meshesMaterialsIntoInternal(fieldId, 0, meshesOut, meshMaterialsOut);
     return out;
 }
 
-void SceneData::lightsInto(const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<UnsignedInt>& fieldDestination) const {
+void SceneData::lightsInto(const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<UnsignedInt>& fieldDestination) const {
     const UnsignedInt fieldId = findFieldIdInternal(SceneField::Light);
     CORRADE_ASSERT(fieldId != ~UnsignedInt{},
         "Trade::SceneData::lightsInto(): field not found", );
-    CORRADE_ASSERT(!objectDestination || objectDestination.size() == _fields[fieldId]._size,
-        "Trade::SceneData::lightsInto(): expected object destination view either empty or with" << _fields[fieldId]._size << "elements but got" << objectDestination.size(), );
+    CORRADE_ASSERT(!mappingDestination || mappingDestination.size() == _fields[fieldId]._size,
+        "Trade::SceneData::lightsInto(): expected mapping destination view either empty or with" << _fields[fieldId]._size << "elements but got" << mappingDestination.size(), );
     CORRADE_ASSERT(!fieldDestination || fieldDestination.size() == _fields[fieldId]._size,
         "Trade::SceneData::lightsInto(): expected field destination view either empty or with" << _fields[fieldId]._size << "elements but got" << fieldDestination.size(), );
-    objectsIntoInternal(fieldId, 0, objectDestination);
+    mappingIntoInternal(fieldId, 0, mappingDestination);
     unsignedIndexFieldIntoInternal(fieldId, 0, fieldDestination);
 }
 
-std::size_t SceneData::lightsInto(const std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<UnsignedInt>& fieldDestination) const {
+std::size_t SceneData::lightsInto(const std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<UnsignedInt>& fieldDestination) const {
     const UnsignedInt fieldId = findFieldIdInternal(SceneField::Light);
     CORRADE_ASSERT(fieldId != ~UnsignedInt{},
         "Trade::SceneData::lightsInto(): field not found", {});
     const std::size_t fieldSize = _fields[fieldId]._size;
     CORRADE_ASSERT(offset <= fieldSize,
         "Trade::SceneData::lightsInto(): offset" << offset << "out of bounds for a field of size" << fieldSize, {});
-    CORRADE_ASSERT(!objectDestination != !fieldDestination|| objectDestination.size() == fieldDestination.size(),
-        "Trade::SceneData::lightsInto(): object and field destination views have different size," << objectDestination.size() << "vs" << fieldDestination.size(), {});
-    const std::size_t size = Math::min(Math::max(objectDestination.size(), fieldDestination.size()), fieldSize - offset);
-    if(objectDestination) objectsIntoInternal(fieldId, offset, objectDestination.prefix(size));
+    CORRADE_ASSERT(!mappingDestination != !fieldDestination|| mappingDestination.size() == fieldDestination.size(),
+        "Trade::SceneData::lightsInto(): mapping and field destination views have different size," << mappingDestination.size() << "vs" << fieldDestination.size(), {});
+    const std::size_t size = Math::min(Math::max(mappingDestination.size(), fieldDestination.size()), fieldSize - offset);
+    if(mappingDestination) mappingIntoInternal(fieldId, offset, mappingDestination.prefix(size));
     if(fieldDestination) unsignedIndexFieldIntoInternal(fieldId, offset, fieldDestination.prefix(size));
     return size;
 }
@@ -1929,29 +1930,29 @@ Containers::Array<Containers::Pair<UnsignedInt, UnsignedInt>> SceneData::lightsA
     return unsignedIndexFieldAsArrayInternal(fieldId);
 }
 
-void SceneData::camerasInto(const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<UnsignedInt>& fieldDestination) const {
+void SceneData::camerasInto(const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<UnsignedInt>& fieldDestination) const {
     const UnsignedInt fieldId = findFieldIdInternal(SceneField::Camera);
     CORRADE_ASSERT(fieldId != ~UnsignedInt{},
         "Trade::SceneData::camerasInto(): field not found", );
-    CORRADE_ASSERT(!objectDestination || objectDestination.size() == _fields[fieldId]._size,
-        "Trade::SceneData::camerasInto(): expected object destination view either empty or with" << _fields[fieldId]._size << "elements but got" << objectDestination.size(), );
+    CORRADE_ASSERT(!mappingDestination || mappingDestination.size() == _fields[fieldId]._size,
+        "Trade::SceneData::camerasInto(): expected mapping destination view either empty or with" << _fields[fieldId]._size << "elements but got" << mappingDestination.size(), );
     CORRADE_ASSERT(!fieldDestination || fieldDestination.size() == _fields[fieldId]._size,
         "Trade::SceneData::camerasInto(): expected field destination view either empty or with" << _fields[fieldId]._size << "elements but got" << fieldDestination.size(), );
-    objectsIntoInternal(fieldId, 0, objectDestination);
+    mappingIntoInternal(fieldId, 0, mappingDestination);
     unsignedIndexFieldIntoInternal(fieldId, 0, fieldDestination);
 }
 
-std::size_t SceneData::camerasInto(const std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<UnsignedInt>& fieldDestination) const {
+std::size_t SceneData::camerasInto(const std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<UnsignedInt>& fieldDestination) const {
     const UnsignedInt fieldId = findFieldIdInternal(SceneField::Camera);
     CORRADE_ASSERT(fieldId != ~UnsignedInt{},
         "Trade::SceneData::camerasInto(): field not found", {});
     const std::size_t fieldSize = _fields[fieldId]._size;
     CORRADE_ASSERT(offset <= fieldSize,
         "Trade::SceneData::camerasInto(): offset" << offset << "out of bounds for a field of size" << fieldSize, {});
-    CORRADE_ASSERT(!objectDestination != !fieldDestination|| objectDestination.size() == fieldDestination.size(),
-        "Trade::SceneData::camerasInto(): object and field destination views have different size," << objectDestination.size() << "vs" << fieldDestination.size(), {});
-    const std::size_t size = Math::min(Math::max(objectDestination.size(), fieldDestination.size()), fieldSize - offset);
-    if(objectDestination) objectsIntoInternal(fieldId, offset, objectDestination.prefix(size));
+    CORRADE_ASSERT(!mappingDestination != !fieldDestination|| mappingDestination.size() == fieldDestination.size(),
+        "Trade::SceneData::camerasInto(): mapping and field destination views have different size," << mappingDestination.size() << "vs" << fieldDestination.size(), {});
+    const std::size_t size = Math::min(Math::max(mappingDestination.size(), fieldDestination.size()), fieldSize - offset);
+    if(mappingDestination) mappingIntoInternal(fieldId, offset, mappingDestination.prefix(size));
     if(fieldDestination) unsignedIndexFieldIntoInternal(fieldId, offset, fieldDestination.prefix(size));
     return size;
 }
@@ -1965,29 +1966,29 @@ Containers::Array<Containers::Pair<UnsignedInt, UnsignedInt>> SceneData::cameras
     return unsignedIndexFieldAsArrayInternal(fieldId);
 }
 
-void SceneData::skinsInto(const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<UnsignedInt>& fieldDestination) const {
+void SceneData::skinsInto(const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<UnsignedInt>& fieldDestination) const {
     const UnsignedInt fieldId = findFieldIdInternal(SceneField::Skin);
     CORRADE_ASSERT(fieldId != ~UnsignedInt{},
         "Trade::SceneData::skinsInto(): field not found", );
-    CORRADE_ASSERT(!objectDestination || objectDestination.size() == _fields[fieldId]._size,
-        "Trade::SceneData::skinsInto(): expected object destination view either empty or with" << _fields[fieldId]._size << "elements but got" << objectDestination.size(), );
+    CORRADE_ASSERT(!mappingDestination || mappingDestination.size() == _fields[fieldId]._size,
+        "Trade::SceneData::skinsInto(): expected mapping destination view either empty or with" << _fields[fieldId]._size << "elements but got" << mappingDestination.size(), );
     CORRADE_ASSERT(!fieldDestination || fieldDestination.size() == _fields[fieldId]._size,
         "Trade::SceneData::skinsInto(): expected field destination view either empty or with" << _fields[fieldId]._size << "elements but got" << fieldDestination.size(), );
-    objectsIntoInternal(fieldId, 0, objectDestination);
+    mappingIntoInternal(fieldId, 0, mappingDestination);
     unsignedIndexFieldIntoInternal(fieldId, 0, fieldDestination);
 }
 
-std::size_t SceneData::skinsInto(const std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<UnsignedInt>& fieldDestination) const {
+std::size_t SceneData::skinsInto(const std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<UnsignedInt>& fieldDestination) const {
     const UnsignedInt fieldId = findFieldIdInternal(SceneField::Skin);
     CORRADE_ASSERT(fieldId != ~UnsignedInt{},
         "Trade::SceneData::skinsInto(): field not found", {});
     const std::size_t fieldSize = _fields[fieldId]._size;
     CORRADE_ASSERT(offset <= fieldSize,
         "Trade::SceneData::skinsInto(): offset" << offset << "out of bounds for a field of size" << fieldSize, {});
-    CORRADE_ASSERT(!objectDestination != !fieldDestination|| objectDestination.size() == fieldDestination.size(),
-        "Trade::SceneData::skinsInto(): object and field destination views have different size," << objectDestination.size() << "vs" << fieldDestination.size(), {});
-    const std::size_t size = Math::min(Math::max(objectDestination.size(), fieldDestination.size()), fieldSize - offset);
-    if(objectDestination) objectsIntoInternal(fieldId, offset, objectDestination.prefix(size));
+    CORRADE_ASSERT(!mappingDestination != !fieldDestination|| mappingDestination.size() == fieldDestination.size(),
+        "Trade::SceneData::skinsInto(): mapping and field destination views have different size," << mappingDestination.size() << "vs" << fieldDestination.size(), {});
+    const std::size_t size = Math::min(Math::max(mappingDestination.size(), fieldDestination.size()), fieldSize - offset);
+    if(mappingDestination) mappingIntoInternal(fieldId, offset, mappingDestination.prefix(size));
     if(fieldDestination) unsignedIndexFieldIntoInternal(fieldId, offset, fieldDestination.prefix(size));
     return size;
 }
@@ -2011,29 +2012,29 @@ void SceneData::importerStateIntoInternal(const UnsignedInt fieldId, const std::
     Utility::copy(Containers::arrayCast<const void* const>(fieldDataFieldViewInternal(field, offset, destination.size())), destination);
 }
 
-void SceneData::importerStateInto(const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<const void*>& fieldDestination) const {
+void SceneData::importerStateInto(const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<const void*>& fieldDestination) const {
     const UnsignedInt fieldId = findFieldIdInternal(SceneField::ImporterState);
     CORRADE_ASSERT(fieldId != ~UnsignedInt{},
         "Trade::SceneData::importerStateInto(): field not found", );
-    CORRADE_ASSERT(!objectDestination || objectDestination.size() == _fields[fieldId]._size,
-        "Trade::SceneData::importerStateInto(): expected object destination view either empty or with" << _fields[fieldId]._size << "elements but got" << objectDestination.size(), );
+    CORRADE_ASSERT(!mappingDestination || mappingDestination.size() == _fields[fieldId]._size,
+        "Trade::SceneData::importerStateInto(): expected mapping destination view either empty or with" << _fields[fieldId]._size << "elements but got" << mappingDestination.size(), );
     CORRADE_ASSERT(!fieldDestination || fieldDestination.size() == _fields[fieldId]._size,
         "Trade::SceneData::importerStateInto(): expected field destination view either empty or with" << _fields[fieldId]._size << "elements but got" << fieldDestination.size(), );
-    objectsIntoInternal(fieldId, 0, objectDestination);
+    mappingIntoInternal(fieldId, 0, mappingDestination);
     importerStateIntoInternal(fieldId, 0, fieldDestination);
 }
 
-std::size_t SceneData::importerStateInto(const std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<const void*>& fieldDestination) const {
+std::size_t SceneData::importerStateInto(const std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<const void*>& fieldDestination) const {
     const UnsignedInt fieldId = findFieldIdInternal(SceneField::ImporterState);
     CORRADE_ASSERT(fieldId != ~UnsignedInt{},
         "Trade::SceneData::importerStateInto(): field not found", {});
     const std::size_t fieldSize = _fields[fieldId]._size;
     CORRADE_ASSERT(offset <= fieldSize,
         "Trade::SceneData::importerStateInto(): offset" << offset << "out of bounds for a field of size" << fieldSize, {});
-    CORRADE_ASSERT(!objectDestination != !fieldDestination|| objectDestination.size() == fieldDestination.size(),
-        "Trade::SceneData::importerStateInto(): object and field destination views have different size," << objectDestination.size() << "vs" << fieldDestination.size(), {});
-    const std::size_t size = Math::min(Math::max(objectDestination.size(), fieldDestination.size()), fieldSize - offset);
-    if(objectDestination) objectsIntoInternal(fieldId, offset, objectDestination.prefix(size));
+    CORRADE_ASSERT(!mappingDestination != !fieldDestination|| mappingDestination.size() == fieldDestination.size(),
+        "Trade::SceneData::importerStateInto(): mapping and field destination views have different size," << mappingDestination.size() << "vs" << fieldDestination.size(), {});
+    const std::size_t size = Math::min(Math::max(mappingDestination.size(), fieldDestination.size()), fieldSize - offset);
+    if(mappingDestination) mappingIntoInternal(fieldId, offset, mappingDestination.prefix(size));
     if(fieldDestination) importerStateIntoInternal(fieldId, offset, fieldDestination.prefix(size));
     return size;
 }
@@ -2055,14 +2056,14 @@ Containers::Array<Containers::Pair<UnsignedInt, const void*>> SceneData::importe
     , std::size_t(_fields[fieldId]._size)};
     /** @todo use slicing once Pair exposes members somehow, especially because
         this is EXTREMELY prone to bugs due to the padding before the pointer */
-    objectsIntoInternal(fieldId, 0, {out, reinterpret_cast<UnsignedInt*>(reinterpret_cast<char*>(out.data())), out.size(), sizeof(decltype(out)::Type)});
+    mappingIntoInternal(fieldId, 0, {out, reinterpret_cast<UnsignedInt*>(reinterpret_cast<char*>(out.data())), out.size(), sizeof(decltype(out)::Type)});
     importerStateIntoInternal(fieldId, 0, {out, reinterpret_cast<const void**>(reinterpret_cast<char*>(out.data()) + sizeof(const void*)), out.size(), sizeof(decltype(out)::Type)});
     return out;
 }
 
 Containers::Optional<Int> SceneData::parentFor(const UnsignedInt object) const {
-    CORRADE_ASSERT(object < _objectCount,
-        "Trade::SceneData::parentFor(): object" << object << "out of bounds for" << _objectCount << "objects", {});
+    CORRADE_ASSERT(object < _mappingBound,
+        "Trade::SceneData::parentFor(): object" << object << "out of bounds for" << _mappingBound << "objects", {});
 
     const UnsignedInt fieldId = findFieldIdInternal(SceneField::Parent);
     if(fieldId == ~UnsignedInt{}) return {};
@@ -2077,8 +2078,8 @@ Containers::Optional<Int> SceneData::parentFor(const UnsignedInt object) const {
 }
 
 Containers::Array<UnsignedInt> SceneData::childrenFor(const Int object) const {
-    CORRADE_ASSERT(object >= -1 && object < Long(_objectCount),
-        "Trade::SceneData::childrenFor(): object" << object << "out of bounds for" << _objectCount << "objects", {});
+    CORRADE_ASSERT(object >= -1 && object < Long(_mappingBound),
+        "Trade::SceneData::childrenFor(): object" << object << "out of bounds for" << _mappingBound << "objects", {});
 
     const UnsignedInt parentFieldId = findFieldIdInternal(SceneField::Parent);
     if(parentFieldId == ~UnsignedInt{}) return {};
@@ -2094,7 +2095,7 @@ Containers::Array<UnsignedInt> SceneData::childrenFor(const Int object) const {
             UnsignedInt child[1];
             /** @todo bleh slow, use the children <-> parent field proxying
                 when implemented */
-            objectsIntoInternal(parentFieldId, offset, child);
+            mappingIntoInternal(parentFieldId, offset, child);
             arrayAppend(out, *child);
         }
     }
@@ -2103,8 +2104,8 @@ Containers::Array<UnsignedInt> SceneData::childrenFor(const Int object) const {
 }
 
 Containers::Optional<Matrix3> SceneData::transformation2DFor(const UnsignedInt object) const {
-    CORRADE_ASSERT(object < _objectCount,
-        "Trade::SceneData::transformation2DFor(): object" << object << "out of bounds for" << _objectCount << "objects", {});
+    CORRADE_ASSERT(object < _mappingBound,
+        "Trade::SceneData::transformation2DFor(): object" << object << "out of bounds for" << _mappingBound << "objects", {});
 
     UnsignedInt transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId;
     const UnsignedInt fieldWithObjectMapping = findTransformFields(transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId);
@@ -2124,8 +2125,8 @@ Containers::Optional<Matrix3> SceneData::transformation2DFor(const UnsignedInt o
 }
 
 Containers::Optional<Containers::Triple<Vector2, Complex, Vector2>> SceneData::translationRotationScaling2DFor(const UnsignedInt object) const {
-    CORRADE_ASSERT(object < _objectCount,
-        "Trade::SceneData::translationRotationScaling2DFor(): object" << object << "out of bounds for" << _objectCount << "objects", {});
+    CORRADE_ASSERT(object < _mappingBound,
+        "Trade::SceneData::translationRotationScaling2DFor(): object" << object << "out of bounds for" << _mappingBound << "objects", {});
 
     UnsignedInt translationFieldId, rotationFieldId, scalingFieldId;
     const UnsignedInt fieldWithObjectMapping = findTranslationRotationScalingFields(translationFieldId, rotationFieldId, scalingFieldId);
@@ -2147,8 +2148,8 @@ Containers::Optional<Containers::Triple<Vector2, Complex, Vector2>> SceneData::t
 }
 
 Containers::Optional<Matrix4> SceneData::transformation3DFor(const UnsignedInt object) const {
-    CORRADE_ASSERT(object < _objectCount,
-        "Trade::SceneData::transformation3DFor(): object" << object << "out of bounds for" << _objectCount << "objects", {});
+    CORRADE_ASSERT(object < _mappingBound,
+        "Trade::SceneData::transformation3DFor(): object" << object << "out of bounds for" << _mappingBound << "objects", {});
 
     UnsignedInt transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId;
     const UnsignedInt fieldWithObjectMapping = findTransformFields(transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId);
@@ -2168,8 +2169,8 @@ Containers::Optional<Matrix4> SceneData::transformation3DFor(const UnsignedInt o
 }
 
 Containers::Optional<Containers::Triple<Vector3, Quaternion, Vector3>> SceneData::translationRotationScaling3DFor(const UnsignedInt object) const {
-    CORRADE_ASSERT(object < _objectCount,
-        "Trade::SceneData::translationRotationScaling3DFor(): object" << object << "out of bounds for" << _objectCount << "objects", {});
+    CORRADE_ASSERT(object < _mappingBound,
+        "Trade::SceneData::translationRotationScaling3DFor(): object" << object << "out of bounds for" << _mappingBound << "objects", {});
 
     UnsignedInt translationFieldId, rotationFieldId, scalingFieldId;
     const UnsignedInt fieldWithObjectMapping = findTranslationRotationScalingFields(translationFieldId, rotationFieldId, scalingFieldId);
@@ -2191,8 +2192,8 @@ Containers::Optional<Containers::Triple<Vector3, Quaternion, Vector3>> SceneData
 }
 
 Containers::Array<Containers::Pair<UnsignedInt, Int>> SceneData::meshesMaterialsFor(const UnsignedInt object) const {
-    CORRADE_ASSERT(object < _objectCount,
-        "Trade::SceneData::meshesMaterialsFor(): object" << object << "out of bounds for" << _objectCount << "objects", {});
+    CORRADE_ASSERT(object < _mappingBound,
+        "Trade::SceneData::meshesMaterialsFor(): object" << object << "out of bounds for" << _mappingBound << "objects", {});
 
     const UnsignedInt meshFieldId = findFieldIdInternal(SceneField::Mesh);
     if(meshFieldId == ~UnsignedInt{}) return {};
@@ -2215,8 +2216,8 @@ Containers::Array<Containers::Pair<UnsignedInt, Int>> SceneData::meshesMaterials
 }
 
 Containers::Array<UnsignedInt> SceneData::lightsFor(const UnsignedInt object) const {
-    CORRADE_ASSERT(object < _objectCount,
-        "Trade::SceneData::lightsFor(): object" << object << "out of bounds for" << _objectCount << "objects", {});
+    CORRADE_ASSERT(object < _mappingBound,
+        "Trade::SceneData::lightsFor(): object" << object << "out of bounds for" << _mappingBound << "objects", {});
 
     const UnsignedInt fieldId = findFieldIdInternal(SceneField::Light);
     if(fieldId == ~UnsignedInt{}) return {};
@@ -2238,8 +2239,8 @@ Containers::Array<UnsignedInt> SceneData::lightsFor(const UnsignedInt object) co
 }
 
 Containers::Array<UnsignedInt> SceneData::camerasFor(const UnsignedInt object) const {
-    CORRADE_ASSERT(object < _objectCount,
-        "Trade::SceneData::camerasFor(): object" << object << "out of bounds for" << _objectCount << "objects", {});
+    CORRADE_ASSERT(object < _mappingBound,
+        "Trade::SceneData::camerasFor(): object" << object << "out of bounds for" << _mappingBound << "objects", {});
 
     const UnsignedInt fieldId = findFieldIdInternal(SceneField::Camera);
     if(fieldId == ~UnsignedInt{}) return {};
@@ -2261,8 +2262,8 @@ Containers::Array<UnsignedInt> SceneData::camerasFor(const UnsignedInt object) c
 }
 
 Containers::Array<UnsignedInt> SceneData::skinsFor(const UnsignedInt object) const {
-    CORRADE_ASSERT(object < _objectCount,
-        "Trade::SceneData::skinsFor(): object" << object << "out of bounds for" << _objectCount << "objects", {});
+    CORRADE_ASSERT(object < _mappingBound,
+        "Trade::SceneData::skinsFor(): object" << object << "out of bounds for" << _mappingBound << "objects", {});
 
     const UnsignedInt fieldId = findFieldIdInternal(SceneField::Skin);
     if(fieldId == ~UnsignedInt{}) return {};
@@ -2284,8 +2285,8 @@ Containers::Array<UnsignedInt> SceneData::skinsFor(const UnsignedInt object) con
 }
 
 Containers::Optional<const void*> SceneData::importerStateFor(const UnsignedInt object) const {
-    CORRADE_ASSERT(object < _objectCount,
-        "Trade::SceneData::importerStateFor(): object" << object << "out of bounds for" << _objectCount << "objects", {});
+    CORRADE_ASSERT(object < _mappingBound,
+        "Trade::SceneData::importerStateFor(): object" << object << "out of bounds for" << _mappingBound << "objects", {});
 
     const UnsignedInt fieldId = findFieldIdInternal(SceneField::ImporterState);
     if(fieldId == ~UnsignedInt{}) return {};
diff --git a/src/Magnum/Trade/SceneData.h b/src/Magnum/Trade/SceneData.h
index 6af7dc26c..a384f3acf 100644
--- a/src/Magnum/Trade/SceneData.h
+++ b/src/Magnum/Trade/SceneData.h
@@ -26,7 +26,7 @@
 */
 
 /** @file
- * @brief Class @ref Magnum::Trade::SceneData, @ref Magnum::Trade::SceneFieldData, enum @ref Magnum::Trade::SceneObjectType, @ref Magnum::Trade::SceneField, @ref Magnum::Trade::SceneFieldType, function @ref Magnum::sceneObjectTypeSize(), @ref Magnum::sceneObjectTypeAlignment(), @ref Magnum::sceneFieldTypeSize(), @ref Magnum::sceneFieldTypeAlignment(), @ref Magnum::Trade::isSceneFieldCustom(), @ref Magnum::sceneFieldCustom()
+ * @brief Class @ref Magnum::Trade::SceneData, @ref Magnum::Trade::SceneFieldData, enum @ref Magnum::Trade::SceneMappingType, @ref Magnum::Trade::SceneField, @ref Magnum::Trade::SceneFieldType, function @ref Magnum::sceneMappingTypeSize(), @ref Magnum::sceneMappingTypeAlignment(), @ref Magnum::sceneFieldTypeSize(), @ref Magnum::sceneFieldTypeAlignment(), @ref Magnum::Trade::isSceneFieldCustom(), @ref Magnum::sceneFieldCustom()
  */
 
 #include <Corrade/Containers/Array.h>
@@ -44,17 +44,17 @@
 namespace Magnum { namespace Trade {
 
 /**
-@brief Scene object type
+@brief Scene object mapping type
 @m_since_latest
 
 Type used for mapping fields to corresponding objects. Unlike
-@ref SceneFieldType that is different for different fields, the object type is
-the same for all fields, and is guaranteed to be large enough to fit all
-@ref SceneData::objectCount() objects.
-@see @ref SceneData::objectType(), @ref sceneObjectTypeSize(),
-    @ref sceneObjectTypeAlignment()
+@ref SceneFieldType that is different for different fields, the object mapping
+type is the same for all fields, and is guaranteed to be large enough to fit
+@ref SceneData::mappingBound() objects.
+@see @ref SceneData::mappingType(), @ref sceneMappingTypeSize(),
+    @ref sceneMappingTypeAlignment()
 */
-enum class SceneObjectType: UnsignedByte {
+enum class SceneMappingType: UnsignedByte {
     /* Zero used for an invalid value */
 
     UnsignedByte = 1,   /**< @relativeref{Magnum,UnsignedByte} */
@@ -64,26 +64,26 @@ enum class SceneObjectType: UnsignedByte {
 };
 
 /**
-@debugoperatorenum{SceneObjectType}
+@debugoperatorenum{SceneMappingType}
 @m_since_latest
 */
-MAGNUM_TRADE_EXPORT Debug& operator<<(Debug& debug, SceneObjectType value);
+MAGNUM_TRADE_EXPORT Debug& operator<<(Debug& debug, SceneMappingType value);
 
 /**
-@brief Size of given scene object type
+@brief Size of given scene object mapping type
 @m_since_latest
 
-@see @ref sceneObjectTypeAlignment()
+@see @ref sceneMappingTypeAlignment()
 */
-MAGNUM_TRADE_EXPORT UnsignedInt sceneObjectTypeSize(SceneObjectType type);
+MAGNUM_TRADE_EXPORT UnsignedInt sceneMappingTypeSize(SceneMappingType type);
 
 /**
-@brief Alignment of given scene object type
+@brief Alignment of given scene object mapping type
 @m_since_latest
 
-Returns the same value as @ref sceneObjectTypeSize().
+Returns the same value as @ref sceneMappingTypeSize().
 */
-MAGNUM_TRADE_EXPORT UnsignedInt sceneObjectTypeAlignment(SceneObjectType type);
+MAGNUM_TRADE_EXPORT UnsignedInt sceneMappingTypeAlignment(SceneMappingType type);
 
 /**
 @brief Scene field name
@@ -543,94 +543,94 @@ class MAGNUM_TRADE_EXPORT SceneFieldData {
          * initialization of the field array for @ref SceneData, expected to be
          * replaced with concrete values later.
          */
-        constexpr explicit SceneFieldData() noexcept: _size{}, _name{}, _isOffsetOnly{}, _objectType{}, _objectStride{}, _objectData{}, _fieldType{}, _fieldStride{}, _fieldArraySize{}, _fieldData{} {}
+        constexpr explicit SceneFieldData() noexcept: _size{}, _name{}, _isOffsetOnly{}, _mappingType{}, _mappingStride{}, _mappingData{}, _fieldType{}, _fieldStride{}, _fieldArraySize{}, _fieldData{} {}
 
         /**
          * @brief Type-erased constructor
          * @param name              Field name
-         * @param objectType        Object type
-         * @param objectData        Object data
+         * @param mappingType       Object mapping type
+         * @param mappingData       Object mapping data
          * @param fieldType         Field type
          * @param fieldData         Field data
          * @param fieldArraySize    Field array size. Use @cpp 0 @ce for
          *      non-array fields.
          *
-         * Expects that @p objectData and @p fieldData have the same size,
+         * Expects that @p mappingData and @p fieldData have the same size,
          * @p fieldType corresponds to @p name and @p fieldArraySize is zero
          * for builtin fields.
          */
-        constexpr explicit SceneFieldData(SceneField name, SceneObjectType objectType, const Containers::StridedArrayView1D<const void>& objectData, SceneFieldType fieldType, const Containers::StridedArrayView1D<const void>& fieldData, UnsignedShort fieldArraySize = 0) noexcept;
+        constexpr explicit SceneFieldData(SceneField name, SceneMappingType mappingType, const Containers::StridedArrayView1D<const void>& mappingData, SceneFieldType fieldType, const Containers::StridedArrayView1D<const void>& fieldData, UnsignedShort fieldArraySize = 0) noexcept;
 
         /**
          * @brief Constructor
          * @param name              Field name
-         * @param objectData        Object data
+         * @param mappingData       Object mapping data
          * @param fieldType         Field type
          * @param fieldData         Field data
          * @param fieldArraySize    Field array size. Use @cpp 0 @ce for
          *      non-array fields.
          *
-         * Expects that @p objectData and @p fieldData have the same size in
-         * the first dimension, that the second dimension of @p objectData is
+         * Expects that @p mappingData and @p fieldData have the same size in
+         * the first dimension, that the second dimension of @p mappingData is
          * contiguous and its size is either 1, 2, 4 or 8, corresponding to one
-         * of the @ref SceneObjectType values, that the second dimension of
+         * of the @ref SceneMappingType values, that the second dimension of
          * @p fieldData is contiguous and its size matches @p fieldType and
          * @p fieldArraySize and that @p fieldType corresponds to @p name and
          * @p fieldArraySize is zero for builtin attributes.
          */
-        explicit SceneFieldData(SceneField name, const Containers::StridedArrayView2D<const char>& objectData, SceneFieldType fieldType, const Containers::StridedArrayView2D<const char>& fieldData, UnsignedShort fieldArraySize = 0) noexcept;
+        explicit SceneFieldData(SceneField name, const Containers::StridedArrayView2D<const char>& mappingData, SceneFieldType fieldType, const Containers::StridedArrayView2D<const char>& fieldData, UnsignedShort fieldArraySize = 0) noexcept;
 
         /**
          * @brief Constructor
          * @param name          Field name
-         * @param objectData    Object data
+         * @param mappingData   Object mapping data
          * @param fieldData     Field data
          *
-         * Detects @ref SceneObjectType based on @p T and @ref SceneFieldType
-         * based on @p U and calls @ref SceneFieldData(SceneField, SceneObjectType, const Containers::StridedArrayView1D<const void>&, SceneFieldType, const Containers::StridedArrayView1D<const void>&, UnsignedShort).
+         * Detects @ref SceneMappingType based on @p T and @ref SceneFieldType
+         * based on @p U and calls @ref SceneFieldData(SceneField, SceneMappingType, const Containers::StridedArrayView1D<const void>&, SceneFieldType, const Containers::StridedArrayView1D<const void>&, UnsignedShort).
          * For all types known by Magnum, the detected @ref SceneFieldType is
          * of the same name as the type (so e.g. @relativeref{Magnum,Vector3ui}
          * gets recognized as @ref SceneFieldType::Vector3ui).
          */
-        template<class T, class U> constexpr explicit SceneFieldData(SceneField name, const Containers::StridedArrayView1D<T>& objectData, const Containers::StridedArrayView1D<U>& fieldData) noexcept;
+        template<class T, class U> constexpr explicit SceneFieldData(SceneField name, const Containers::StridedArrayView1D<T>& mappingData, const Containers::StridedArrayView1D<U>& fieldData) noexcept;
 
         /** @overload */
-        template<class T, class U> constexpr explicit SceneFieldData(SceneField name, const Containers::StridedArrayView1D<T>& objectData, const Containers::ArrayView<U>& fieldData) noexcept: SceneFieldData{name, objectData, Containers::stridedArrayView(fieldData)} {}
+        template<class T, class U> constexpr explicit SceneFieldData(SceneField name, const Containers::StridedArrayView1D<T>& mappingData, const Containers::ArrayView<U>& fieldData) noexcept: SceneFieldData{name, mappingData, Containers::stridedArrayView(fieldData)} {}
 
         /** @overload */
-        template<class T, class U> constexpr explicit SceneFieldData(SceneField name, const Containers::ArrayView<T>& objectData, const Containers::StridedArrayView1D<U>& fieldData) noexcept: SceneFieldData{name, Containers::stridedArrayView(objectData), fieldData} {}
+        template<class T, class U> constexpr explicit SceneFieldData(SceneField name, const Containers::ArrayView<T>& mappingData, const Containers::StridedArrayView1D<U>& fieldData) noexcept: SceneFieldData{name, Containers::stridedArrayView(mappingData), fieldData} {}
 
         /** @overload */
-        template<class T, class U> constexpr explicit SceneFieldData(SceneField name, const Containers::ArrayView<T>& objectData, const Containers::ArrayView<U>& fieldData) noexcept: SceneFieldData{name, Containers::stridedArrayView(objectData), Containers::stridedArrayView(fieldData)} {}
+        template<class T, class U> constexpr explicit SceneFieldData(SceneField name, const Containers::ArrayView<T>& mappingData, const Containers::ArrayView<U>& fieldData) noexcept: SceneFieldData{name, Containers::stridedArrayView(mappingData), Containers::stridedArrayView(fieldData)} {}
 
         /**
          * @brief Construct an array field
          * @param name          Field name
-         * @param objectData    Object data
+         * @param mappingData   Object mapping data
          * @param fieldData     Field data
          *
-         * Detects @ref SceneObjectType based on @p T and @ref SceneFieldType
-         * based on @p U and calls @ref SceneFieldData(SceneField, SceneObjectType, const Containers::StridedArrayView1D<const void>&, SceneFieldType, const Containers::StridedArrayView1D<const void>&, UnsignedShort)
+         * Detects @ref SceneMappingType based on @p T and @ref SceneFieldType
+         * based on @p U and calls @ref SceneFieldData(SceneField, SceneMappingType, const Containers::StridedArrayView1D<const void>&, SceneFieldType, const Containers::StridedArrayView1D<const void>&, UnsignedShort)
          * with the @p fieldData second dimension size passed to
          * @p fieldArraySize. Expects that the second dimension of @p fieldData
          * is contiguous. At the moment only custom fields can be arrays, which
          * means this function can't be used with a builtin @p name. See
          * @ref SceneFieldData(SceneField, const Containers::StridedArrayView1D<T>&, const Containers::StridedArrayView1D<U>&)
-         * for details about @ref SceneObjectType and @ref SceneFieldType
+         * for details about @ref SceneMappingType and @ref SceneFieldType
          * detection.
          */
-        template<class T, class U> constexpr explicit SceneFieldData(SceneField name, const Containers::StridedArrayView1D<T>& objectData, const Containers::StridedArrayView2D<U>& fieldData) noexcept;
+        template<class T, class U> constexpr explicit SceneFieldData(SceneField name, const Containers::StridedArrayView1D<T>& mappingData, const Containers::StridedArrayView2D<U>& fieldData) noexcept;
 
         /** @overload */
-        template<class T, class U> constexpr explicit SceneFieldData(SceneField name, const Containers::ArrayView<T>& objectData, const Containers::StridedArrayView2D<U>& fieldData) noexcept: SceneFieldData{name, Containers::stridedArrayView(objectData), fieldData} {}
+        template<class T, class U> constexpr explicit SceneFieldData(SceneField name, const Containers::ArrayView<T>& mappingData, const Containers::StridedArrayView2D<U>& fieldData) noexcept: SceneFieldData{name, Containers::stridedArrayView(mappingData), fieldData} {}
 
         /**
          * @brief Construct an offset-only field
          * @param name              Field name
          * @param size              Number of entries
-         * @param objectType        Object type
-         * @param objectOffset      Object data offset
-         * @param objectStride      Object data stride
+         * @param mappingType       Object mapping type
+         * @param mappingOffset     Object mapping data offset
+         * @param mappingStride     Object mapping data stride
          * @param fieldType         Field type
          * @param fieldOffset       Field data offset
          * @param fieldStride       Field data stride
@@ -644,24 +644,24 @@ class MAGNUM_TRADE_EXPORT SceneFieldData {
          * @p name and @p fieldArraySize is zero for builtin attributes.
          *
          * Note that due to the @cpp constexpr @ce nature of this constructor,
-         * no @p objectType checks against @p objectStride or
+         * no @p mappingType checks against @p mappingStride or
          * @p fieldType / @p fieldArraySize checks against @p fieldStride can
-         * be done. You're encouraged to use the @ref SceneFieldData(SceneField, SceneObjectType, const Containers::StridedArrayView1D<const void>&, SceneFieldType, const Containers::StridedArrayView1D<const void>&, UnsignedShort)
+         * be done. You're encouraged to use the @ref SceneFieldData(SceneField, SceneMappingType, const Containers::StridedArrayView1D<const void>&, SceneFieldType, const Containers::StridedArrayView1D<const void>&, UnsignedShort)
          * constructor if you want additional safeguards.
          * @see @ref isOffsetOnly(), @ref fieldArraySize(),
-         *      @ref objectData(Containers::ArrayView<const void>) const,
+         *      @ref mappingData(Containers::ArrayView<const void>) const,
          *      @ref fieldData(Containers::ArrayView<const void>) const
          */
-        explicit constexpr SceneFieldData(SceneField name, std::size_t size, SceneObjectType objectType, std::size_t objectOffset, std::ptrdiff_t objectStride, SceneFieldType fieldType, std::size_t fieldOffset, std::ptrdiff_t fieldStride, UnsignedShort fieldArraySize = 0) noexcept;
+        explicit constexpr SceneFieldData(SceneField name, std::size_t size, SceneMappingType mappingType, std::size_t mappingOffset, std::ptrdiff_t mappingStride, SceneFieldType fieldType, std::size_t fieldOffset, std::ptrdiff_t fieldStride, UnsignedShort fieldArraySize = 0) noexcept;
 
         /**
          * @brief If the field is offset-only
          *
          * Returns @cpp true @ce if the field doesn't contain the data views
          * directly, but instead refers to unspecified external data.
-         * @see @ref objectData(Containers::ArrayView<const void>) const,
+         * @see @ref mappingData(Containers::ArrayView<const void>) const,
          *      @ref fieldData(Containers::ArrayView<const void>) const,
-         *      @ref SceneFieldData(SceneField, std::size_t, SceneObjectType, std::size_t, std::ptrdiff_t, SceneFieldType, std::size_t, std::ptrdiff_t, UnsignedShort)
+         *      @ref SceneFieldData(SceneField, std::size_t, SceneMappingType, std::size_t, std::ptrdiff_t, SceneFieldType, std::size_t, std::ptrdiff_t, UnsignedShort)
          */
         constexpr bool isOffsetOnly() const { return _isOffsetOnly; }
 
@@ -671,36 +671,36 @@ class MAGNUM_TRADE_EXPORT SceneFieldData {
         /** @brief Number of entries */
         constexpr UnsignedLong size() const { return _size; }
 
-        /** @brief Object type */
-        constexpr SceneObjectType objectType() const { return _objectType; }
+        /** @brief Object mapping type */
+        constexpr SceneMappingType mappingType() const { return _mappingType; }
 
         /**
-         * @brief Type-erased object data
+         * @brief Type-erased object mapping data
          *
          * Expects that the field is not offset-only, in that case use the
-         * @ref objectData(Containers::ArrayView<const void>) const overload
+         * @ref mappingData(Containers::ArrayView<const void>) const overload
          * instead.
          * @see @ref isOffsetOnly()
          */
-        constexpr Containers::StridedArrayView1D<const void> objectData() const {
+        constexpr Containers::StridedArrayView1D<const void> mappingData() const {
             return Containers::StridedArrayView1D<const void>{
                 /* We're *sure* the view is correct, so faking the view size */
                 /** @todo better ideas for the StridedArrayView API? */
-                {_objectData.pointer, ~std::size_t{}}, _size,
-                (CORRADE_CONSTEXPR_ASSERT(!_isOffsetOnly, "Trade::SceneFieldData::objectData(): the field is offset-only, supply a data array"), _objectStride)};
+                {_mappingData.pointer, ~std::size_t{}}, _size,
+                (CORRADE_CONSTEXPR_ASSERT(!_isOffsetOnly, "Trade::SceneFieldData::mappingData(): the field is offset-only, supply a data array"), _mappingStride)};
         }
 
         /**
-         * @brief Type-erased object data for an offset-only attribute
+         * @brief Type-erased object mapping data for an offset-only attribute
          *
          * If the field is not offset-only, the @p data parameter is ignored.
-         * @see @ref isOffsetOnly(), @ref objectData() const
+         * @see @ref isOffsetOnly(), @ref mappingData() const
          */
-        Containers::StridedArrayView1D<const void> objectData(Containers::ArrayView<const void> data) const {
+        Containers::StridedArrayView1D<const void> mappingData(Containers::ArrayView<const void> data) const {
             return Containers::StridedArrayView1D<const void>{
                 /* We're *sure* the view is correct, so faking the view size */
                 /** @todo better ideas for the StridedArrayView API? */
-                data, _isOffsetOnly ? reinterpret_cast<const char*>(data.data()) + _objectData.offset : _objectData.pointer, _size, _objectStride};
+                data, _isOffsetOnly ? reinterpret_cast<const char*>(data.data()) + _mappingData.offset : _mappingData.pointer, _size, _mappingStride};
         }
 
         /** @brief Field type */
@@ -755,9 +755,9 @@ class MAGNUM_TRADE_EXPORT SceneFieldData {
         UnsignedLong _size;
         SceneField _name;
         bool _isOffsetOnly;
-        SceneObjectType _objectType;
-        Short _objectStride;
-        Data _objectData;
+        SceneMappingType _mappingType;
+        Short _mappingStride;
+        Data _mappingData;
 
         SceneFieldType _fieldType;
         Short _fieldStride;
@@ -788,58 +788,60 @@ class MAGNUM_TRADE_EXPORT SceneData {
     public:
         /**
          * @brief Construct scene data
-         * @param objectType    Object type
-         * @param objectCount   Total count of all objects in the scene
-         * @param data          Data for all fields and objects
+         * @param mappingType   Object mapping type
+         * @param mappingBound  Upper bound on object mapping indices in the
+         *      scene
+         * @param data          Data for all fields and object mappings
          * @param fields        Description of all scene field data
          * @param importerState Importer-specific state
          * @m_since_latest
          *
-         * The @p objectType is expected to be large enough to index all
-         * @p objectCount objects. The @p fields are expected to reference
+         * The @p mappingType is expected to be large enough to index
+         * @p mappingBound objects. The @p fields are expected to reference
          * (sparse) sub-ranges of @p data, each having an unique
-         * @ref SceneField and @ref SceneObjectType equal to @p objectType.
+         * @ref SceneField, and @ref SceneMappingType equal to @p mappingType.
          * Particular fields can have additional restrictions, see
          * documentation of @ref SceneField values for more information.
          *
          * The @ref dataFlags() are implicitly set to a combination of
          * @ref DataFlag::Owned and @ref DataFlag::Mutable. For non-owned data
-         * use the @ref SceneData(SceneObjectType, UnsignedLong, DataFlags, Containers::ArrayView<const void>, Containers::Array<SceneFieldData>&&, const void*)
+         * use the @ref SceneData(SceneMappingType, UnsignedLong, DataFlags, Containers::ArrayView<const void>, Containers::Array<SceneFieldData>&&, const void*)
          * constructor or its variants instead.
          */
-        explicit SceneData(SceneObjectType objectType, UnsignedLong objectCount, Containers::Array<char>&& data, Containers::Array<SceneFieldData>&& fields, const void* importerState = nullptr) noexcept;
+        explicit SceneData(SceneMappingType mappingType, UnsignedLong mappingBound, Containers::Array<char>&& data, Containers::Array<SceneFieldData>&& fields, const void* importerState = nullptr) noexcept;
 
         /**
          * @overload
          * @m_since_latest
          */
         /* Not noexcept because allocation happens inside */
-        explicit SceneData(SceneObjectType objectType, UnsignedLong objectCount, Containers::Array<char>&& data, std::initializer_list<SceneFieldData> fields, const void* importerState = nullptr);
+        explicit SceneData(SceneMappingType mappingType, UnsignedLong mappingBound, Containers::Array<char>&& data, std::initializer_list<SceneFieldData> fields, const void* importerState = nullptr);
 
         /**
          * @brief Construct non-owned scene data
-         * @param objectType    Object type
-         * @param objectCount   Total count of all objects in the scene
+         * @param mappingType   Object mapping type
+         * @param mappingBound  Upper bound on object mapping indices in the
+         *      scene
          * @param dataFlags     Data flags
-         * @param data          View on data for all fields and objects
+         * @param data          View on data for all fields and object mappings
          * @param fields        Description of all scene field data
          * @param importerState Importer-specific state
          * @m_since_latest
          *
-         * Compared to @ref SceneData(SceneObjectType, UnsignedLong, Containers::Array<char>&&, Containers::Array<SceneFieldData>&&, const void*)
+         * Compared to @ref SceneData(SceneMappingType, UnsignedLong, Containers::Array<char>&&, Containers::Array<SceneFieldData>&&, const void*)
          * creates an instance that doesn't own the passed data. The
          * @p dataFlags parameter can contain @ref DataFlag::Mutable to
          * indicate the external data can be modified, and is expected to *not*
          * have @ref DataFlag::Owned set.
          */
-        explicit SceneData(SceneObjectType objectType, UnsignedLong objectCount, DataFlags dataFlags, Containers::ArrayView<const void> data, Containers::Array<SceneFieldData>&& fields, const void* importerState = nullptr) noexcept;
+        explicit SceneData(SceneMappingType mappingType, UnsignedLong mappingBound, DataFlags dataFlags, Containers::ArrayView<const void> data, Containers::Array<SceneFieldData>&& fields, const void* importerState = nullptr) noexcept;
 
         /**
          * @overload
          * @m_since_latest
          */
         /* Not noexcept because allocation happens inside */
-        explicit SceneData(SceneObjectType objectType, UnsignedLong objectCount, DataFlags dataFlags, Containers::ArrayView<const void> data, std::initializer_list<SceneFieldData> fields, const void* importerState = nullptr);
+        explicit SceneData(SceneMappingType mappingType, UnsignedLong mappingBound, DataFlags dataFlags, Containers::ArrayView<const void> data, std::initializer_list<SceneFieldData> fields, const void* importerState = nullptr);
 
         #ifdef MAGNUM_BUILD_DEPRECATED
          /**
@@ -847,10 +849,10 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @param children2D        Two-dimensional child objects
          * @param children3D        Three-dimensional child objects
          * @param importerState     Importer-specific state
-         * @m_deprecated_since_latest Use @ref SceneData(SceneObjectType, UnsignedLong, Containers::Array<char>&&, Containers::Array<SceneFieldData>&&, const void*)
+         * @m_deprecated_since_latest Use @ref SceneData(SceneMappingType, UnsignedLong, Containers::Array<char>&&, Containers::Array<SceneFieldData>&&, const void*)
          *      instead.
          */
-        explicit CORRADE_DEPRECATED("use SceneData(SceneObjectType, UnsignedLong, Containers::Array<char>&&, Containers::Array<SceneFieldData>&&, const void*) instead") SceneData(std::vector<UnsignedInt> children2D, std::vector<UnsignedInt> children3D, const void* importerState = nullptr);
+        explicit CORRADE_DEPRECATED("use SceneData(SceneMappingType, UnsignedLong, Containers::Array<char>&&, Containers::Array<SceneFieldData>&&, const void*) instead") SceneData(std::vector<UnsignedInt> children2D, std::vector<UnsignedInt> children3D, const void* importerState = nullptr);
         #endif
 
         /** @brief Copying is not allowed */
@@ -871,8 +873,8 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @brief Data flags
          * @m_since_latest
          *
-         * @see @ref releaseData(), @ref mutableData(), @ref mutableField(),
-         *      @ref mutableObjects()
+         * @see @ref releaseData(), @ref mutableData(), @ref mutableMapping(),
+         *      @ref mutableField()
          */
         DataFlags dataFlags() const { return _dataFlags; }
 
@@ -910,20 +912,20 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @brief Type used for object mapping
          * @m_since_latest
          *
-         * Type returned from @ref objects() and @ref mutableObjects(). It's
+         * Type returned from @ref mapping() and @ref mutableMapping(). It's
          * the same for all fields and is guaranteed to be large enough to fit
-         * all @ref objectCount() objects.
+         * @ref mappingBound() objects.
          */
-        SceneObjectType objectType() const { return _objectType; }
+        SceneMappingType mappingType() const { return _mappingType; }
 
         /**
-         * @brief Total object count
+         * @brief Object mapping bound
          * @m_since_latest
          *
-         * Total number of objects contained in the scene.
+         * Upper bound on object mapping indices of all fields in the scene.
          * @see @ref fieldCount(), @ref fieldSize()
          */
-        UnsignedLong objectCount() const { return _objectCount; }
+        UnsignedLong mappingBound() const { return _mappingBound; }
 
         /**
          * @brief Field count
@@ -933,8 +935,7 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * a scene with no fields. Each @ref SceneField can be present only
          * once, however an object can have a certain field associated with it
          * multiple times with different values (for example an object having
-         * multiple meshes). See also @ref objectCount() which returns count of
-         * actual objects.
+         * multiple meshes).
          */
         UnsignedInt fieldCount() const { return _fields.size(); }
 
@@ -945,7 +946,7 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * Returns the raw data that are used as a base for all `field*()`
          * accessors, or @cpp nullptr @ce if the scene has no fields. In most
          * cases you don't want to access those directly, but rather use the
-         * @ref objects(), @ref field(), @ref fieldName(), @ref fieldType(),
+         * @ref mapping(), @ref field(), @ref fieldName(), @ref fieldType(),
          * @ref fieldSize() and @ref fieldArraySize() accessors. Compared to
          * those and to @ref fieldData(UnsignedInt) const, the
          * @ref SceneFieldData instances returned by this function may have
@@ -967,7 +968,7 @@ class MAGNUM_TRADE_EXPORT SceneData {
          *
          * Returns the raw data that are used as a base for all `field*()`
          * accessors. In most cases you don't want to access those directly,
-         * but rather use the @ref objects(), @ref field(), @ref fieldName(),
+         * but rather use the @ref mapping(), @ref field(), @ref fieldName(),
          * @ref fieldType(), @ref fieldSize() and @ref fieldArraySize()
          * accessors. This is also the reason why there's no overload taking a
          * @ref SceneField, unlike the other accessors.
@@ -998,7 +999,7 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * The @p id is expected to be smaller than @ref fieldCount(). You can
          * also use @ref fieldType(SceneField) const to directly get a type of
          * given named field.
-         * @see @ref fieldName(), @ref objectType()
+         * @see @ref fieldName(), @ref mappingType()
          */
         SceneFieldType fieldType(UnsignedInt id) const;
 
@@ -1006,9 +1007,9 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @brief Size of given field
          * @m_since_latest
          *
-         * Size of the view returned by @ref field() / @ref mutableField() and
-         * also @ref objects() / @ref mutableObjects() for given @p id. Since
-         * an object can have multiple entries of the same field (for example
+         * Size of the view returned by @ref mapping() / @ref mutableMapping()
+         * and @ref field() / @ref mutableField() for given @p id. Since an
+         * object can have multiple entries of the same field (for example
          * multiple meshes associated with an object), the size doesn't
          * necessarily match the number of objects having given field.
          *
@@ -1107,7 +1108,7 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * If @p object isn't present in @p fieldId starting at @p offset,
          * returns @ref Containers::NullOpt. The @p fieldId is expected to be
          * smaller than @ref fieldCount(), @p object smaller than
-         * @ref objectCount() and @p offset not larger than
+         * @ref mappingBound() and @p offset not larger than
          * @ref fieldSize(UnsignedInt) const.
          *
          * The lookup is done in an @f$ \mathcal{O}(n) @f$ complexity with
@@ -1126,7 +1127,7 @@ class MAGNUM_TRADE_EXPORT SceneData {
          *
          * If @p object isn't present in @p fieldName starting at @p offset,
          * returns @ref Containers::NullOpt. The @p fieldName is expected to
-         * exist, @p object is expected to be smaller than @ref objectCount()
+         * exist, @p object is expected to be smaller than @ref mappingBound()
          * and @p offset not be larger than @ref fieldSize(SceneField) const.
          *
          * The lookup is done in an @f$ \mathcal{O}(m + n) @f$ complexity with
@@ -1165,7 +1166,7 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @m_since_latest
          *
          * The @p fieldId is expected to be smaller than @ref fieldCount() and
-         * @p object smaller than @ref objectCount().
+         * @p object smaller than @ref mappingBound().
          */
         bool hasFieldObject(UnsignedInt fieldId, UnsignedInt object) const;
 
@@ -1174,7 +1175,7 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @m_since_latest
          *
          * The @p fieldName is expected to exist and @p object is expected to
-         * be smaller than @ref objectCount().
+         * be smaller than @ref mappingBound().
          * @see @ref hasField()
          */
         bool hasFieldObject(SceneField fieldName, UnsignedInt object) const;
@@ -1212,33 +1213,33 @@ class MAGNUM_TRADE_EXPORT SceneData {
          *
          * The @p fieldId is expected to be smaller than @ref fieldCount(). The
          * second dimension represents the actual data type (its size is equal
-         * to @ref SceneObjectType size) and is guaranteed to be contiguous.
-         * Use the templated overload below to get the objects in a concrete
+         * to @ref SceneMappingType size) and is guaranteed to be contiguous.
+         * Use the templated overload below to get the mapping in a concrete
          * type.
-         * @see @ref mutableObjects(UnsignedInt),
+         * @see @ref mutableMapping(UnsignedInt),
          *      @ref Corrade::Containers::StridedArrayView::isContiguous(),
-         *      @ref sceneObjectTypeSize()
+         *      @ref sceneMappingTypeSize()
          */
-        Containers::StridedArrayView2D<const char> objects(UnsignedInt fieldId) const;
+        Containers::StridedArrayView2D<const char> mapping(UnsignedInt fieldId) const;
 
         /**
          * @brief Mutable object mapping data for given field
          * @m_since_latest
          *
-         * Like @ref objects(UnsignedInt) const, but returns a mutable view.
+         * Like @ref mapping(UnsignedInt) const, but returns a mutable view.
          * Expects that the scene is mutable.
          * @see @ref dataFlags()
          */
-        Containers::StridedArrayView2D<char> mutableObjects(UnsignedInt fieldId);
+        Containers::StridedArrayView2D<char> mutableMapping(UnsignedInt fieldId);
 
         /**
          * @brief Object mapping for given field
          * @m_since_latest
          *
          * The @p fieldId is expected to be smaller than @ref fieldCount() and
-         * @p T is expected to correspond to @ref objectType().
+         * @p T is expected to correspond to @ref mappingType().
          *
-         * You can also use the non-templated @ref objectsAsArray() accessor
+         * You can also use the non-templated @ref mappingAsArray() accessor
          * (or the combined @ref parentsAsArray(),
          * @ref transformations2DAsArray(), @ref transformations3DAsArray(),
          * @ref translationsRotationsScalings2DAsArray(),
@@ -1248,19 +1249,19 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @ref importerStateAsArray() accessors) to get the object mapping
          * converted to the usual type, but note that these operations involve
          * extra allocation and data conversion.
-         * @see @ref mutableObjects(UnsignedInt)
+         * @see @ref mutableMapping(UnsignedInt)
          */
-        template<class T> Containers::StridedArrayView1D<const T> objects(UnsignedInt fieldId) const;
+        template<class T> Containers::StridedArrayView1D<const T> mapping(UnsignedInt fieldId) const;
 
         /**
          * @brief Mutable object mapping for given field
          * @m_since_latest
          *
-         * Like @ref objects(UnsignedInt) const, but returns a mutable view.
+         * Like @ref mapping(UnsignedInt) const, but returns a mutable view.
          * Expects that the scene is mutable.
          * @see @ref dataFlags()
          */
-        template<class T> Containers::StridedArrayView1D<T> mutableObjects(UnsignedInt fieldId);
+        template<class T> Containers::StridedArrayView1D<T> mutableMapping(UnsignedInt fieldId);
 
         /**
          * @brief Object mapping data for given named field
@@ -1268,32 +1269,33 @@ class MAGNUM_TRADE_EXPORT SceneData {
          *
          * The @p fieldName is expected to exist. The second dimension
          * represents the actual data type (its size is equal to
-         * @ref SceneObjectType size) and is guaranteed to be contiguous. Use
-         * the templated overload below to get the objects in a concrete type.
-         * @see @ref hasField(), @ref objects(UnsignedInt) const,
-         *      @ref mutableObjects(SceneField),
+         * @ref SceneMappingType size) and is guaranteed to be contiguous. Use
+         * the templated overload below to get the object mapping in a concrete
+         * type.
+         * @see @ref hasField(), @ref mapping(UnsignedInt) const,
+         *      @ref mutableMapping(SceneField),
          *      @ref Corrade::Containers::StridedArrayView::isContiguous()
          */
-        Containers::StridedArrayView2D<const char> objects(SceneField fieldName) const;
+        Containers::StridedArrayView2D<const char> mapping(SceneField fieldName) const;
 
         /**
          * @brief Mutable object mapping data for given named field
          * @m_since_latest
          *
-         * Like @ref objects(SceneField) const, but returns a mutable view.
+         * Like @ref mapping(SceneField) const, but returns a mutable view.
          * Expects that the scene is mutable.
          * @see @ref dataFlags()
          */
-        Containers::StridedArrayView2D<char> mutableObjects(SceneField fieldName);
+        Containers::StridedArrayView2D<char> mutableMapping(SceneField fieldName);
 
         /**
          * @brief Object mapping for given named field
          * @m_since_latest
          *
          * The @p fieldName is expected to exist and @p T is expected to
-         * correspond to @ref objectType().
+         * correspond to @ref mappingType().
          *
-         * You can also use the non-templated @ref objectsAsArray() accessor
+         * You can also use the non-templated @ref mappingAsArray() accessor
          * (or the combined @ref parentsAsArray(),
          * @ref transformations2DAsArray(), @ref transformations3DAsArray(),
          * @ref translationsRotationsScalings2DAsArray(),
@@ -1303,20 +1305,20 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @ref importerStateAsArray() accessors) to get the object mapping
          * converted to the usual type, but note that these operations involve
          * extra allocation and data conversion.
-         * @see @ref hasField(), @ref objects(UnsignedInt) const,
-         *      @ref mutableObjects(UnsignedInt)
+         * @see @ref hasField(), @ref mapping(UnsignedInt) const,
+         *      @ref mutableMapping(UnsignedInt)
          */
-        template<class T> Containers::StridedArrayView1D<const T> objects(SceneField fieldName) const;
+        template<class T> Containers::StridedArrayView1D<const T> mapping(SceneField fieldName) const;
 
         /**
          * @brief Mutable object mapping for given named field
          * @m_since_latest
          *
-         * Like @ref objects(SceneField) const, but returns a mutable view.
+         * Like @ref mapping(SceneField) const, but returns a mutable view.
          * Expects that the scene is mutable.
          * @see @ref dataFlags()
          */
-        template<class T> Containers::StridedArrayView1D<T> mutableObjects(SceneField fieldName);
+        template<class T> Containers::StridedArrayView1D<T> mutableMapping(SceneField fieldName);
 
         /**
          * @brief Data for given field
@@ -1485,7 +1487,7 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @m_since_latest
          *
          * Convenience alternative to the templated
-         * @ref objects(UnsignedInt) const that converts the field from an
+         * @ref mapping(UnsignedInt) const that converts the field from an
          * arbitrary underlying type and returns it in a newly-allocated array.
          * The @p fieldId is expected to be smaller than @ref fieldCount().
          *
@@ -1498,15 +1500,15 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @ref camerasAsArray(), @ref skinsAsArray(),
          * @ref importerStateAsArray() accessors, which give out the object
          * mapping together with the field data.
-         * @see @ref objectsInto(UnsignedInt, const Containers::StridedArrayView1D<UnsignedInt>&) const
+         * @see @ref mappingInto(UnsignedInt, const Containers::StridedArrayView1D<UnsignedInt>&) const
          */
-        Containers::Array<UnsignedInt> objectsAsArray(UnsignedInt fieldId) const;
+        Containers::Array<UnsignedInt> mappingAsArray(UnsignedInt fieldId) const;
 
         /**
          * @brief Object mapping for given field as 32-bit integers into a pre-allocated view
          * @m_since_latest
          *
-         * Like @ref objectsAsArray(UnsignedInt) const, but puts the result
+         * Like @ref mappingAsArray(UnsignedInt) const, but puts the result
          * into @p destination instead of allocating a new array. Expects that
          * @p destination is sized to contain exactly all data.
          *
@@ -1521,13 +1523,13 @@ class MAGNUM_TRADE_EXPORT SceneData {
          *
          * @see @ref fieldSize(UnsignedInt) const
          */
-        void objectsInto(UnsignedInt fieldId, const Containers::StridedArrayView1D<UnsignedInt>& destination) const;
+        void mappingInto(UnsignedInt fieldId, const Containers::StridedArrayView1D<UnsignedInt>& destination) const;
 
         /**
          * @brief A subrange of object mapping for given field as 32-bit integers into a pre-allocated view
          * @m_since_latest
          *
-         * Compared to @ref objectsInto(UnsignedInt, const Containers::StridedArrayView1D<UnsignedInt>&) const
+         * Compared to @ref mappingInto(UnsignedInt, const Containers::StridedArrayView1D<UnsignedInt>&) const
          * extracts only a subrange of the object mapping defined by @p offset
          * and size of the @p destination view, returning the count of items
          * actually extracted. The @p offset is expected to not be larger than
@@ -1545,14 +1547,14 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @see @ref fieldSize(UnsignedInt) const,
          *      @ref fieldObjectOffset(UnsignedInt, UnsignedInt, std::size_t) const
          */
-        std::size_t objectsInto(UnsignedInt fieldId, std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& destination) const;
+        std::size_t mappingInto(UnsignedInt fieldId, std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& destination) const;
 
         /**
          * @brief Object mapping for given named field as 32-bit integers
          * @m_since_latest
          *
          * Convenience alternative to the templated
-         * @ref objects(SceneField) const that converts the field from an
+         * @ref mapping(SceneField) const that converts the field from an
          * arbitrary underlying type and returns it in a newly-allocated array.
          * The @p fieldName is expected to exist.
          *
@@ -1565,16 +1567,16 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @ref camerasAsArray(), @ref skinsAsArray(),
          * @ref importerStateAsArray() accessors, which give out the object
          * mapping together with the field data.
-         * @see @ref objectsInto(SceneField, const Containers::StridedArrayView1D<UnsignedInt>&) const,
+         * @see @ref mappingInto(SceneField, const Containers::StridedArrayView1D<UnsignedInt>&) const,
          *      @ref hasField()
          */
-        Containers::Array<UnsignedInt> objectsAsArray(SceneField fieldName) const;
+        Containers::Array<UnsignedInt> mappingAsArray(SceneField fieldName) const;
 
         /**
          * @brief Object mapping for given named field as 32-bit integers into a pre-allocated view
          * @m_since_latest
          *
-         * Like @ref objectsAsArray(SceneField) const, but puts the result into
+         * Like @ref mappingAsArray(SceneField) const, but puts the result into
          * @p destination instead of allocating a new array. Expects that
          * @p destination is sized to contain exactly all data.
          *
@@ -1589,13 +1591,13 @@ class MAGNUM_TRADE_EXPORT SceneData {
          *
          * @see @ref fieldSize(SceneField) const
          */
-        void objectsInto(SceneField fieldName, const Containers::StridedArrayView1D<UnsignedInt>& destination) const;
+        void mappingInto(SceneField fieldName, const Containers::StridedArrayView1D<UnsignedInt>& destination) const;
 
         /**
          * @brief A subrange of object mapping for given named field as 32-bit integers into a pre-allocated view
          * @m_since_latest
          *
-         * Compared to @ref objectsInto(SceneField, const Containers::StridedArrayView1D<UnsignedInt>&) const
+         * Compared to @ref mappingInto(SceneField, const Containers::StridedArrayView1D<UnsignedInt>&) const
          * extracts only a subrange of the object mapping defined by @p offset
          * and size of the @p destination view, returning the count of items
          * actually extracted. The @p offset is expected to not be larger than
@@ -1613,13 +1615,13 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @see @ref fieldSize(SceneField) const,
          *      @ref fieldObjectOffset(SceneField, UnsignedInt, std::size_t) const
          */
-        std::size_t objectsInto(SceneField fieldName, std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& destination) const;
+        std::size_t mappingInto(SceneField fieldName, std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& destination) const;
 
         /**
          * @brief Parent indices as 32-bit integers
          * @m_since_latest
          *
-         * Convenience alternative to @ref objects(SceneField) const together
+         * Convenience alternative to @ref mapping(SceneField) const together
          * with @ref field(SceneField) const with @ref SceneField::Parent as
          * the argument. Converts the object mapping and the field from
          * arbitrary underlying types and returns them in a newly-allocated
@@ -1634,14 +1636,14 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @m_since_latest
          *
          * Like @ref parentsAsArray(), but puts the result into
-         * @p objectDestination and @p fieldDestination instead of allocating a
-         * new array. Expects that each view is either @cpp nullptr @ce or
+         * @p mappingDestination and @p fieldDestination instead of allocating
+         * a new array. Expects that each view is either @cpp nullptr @ce or
          * sized to contain exactly all data. If @p fieldDestination is
          * @cpp nullptr @ce, the effect is the same as calling
-         * @ref objectsInto() with @ref SceneField::Parent.
+         * @ref mappingInto() with @ref SceneField::Parent.
          * @see @ref fieldSize(SceneField) const
          */
-        void parentsInto(const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<Int>& fieldDestination) const;
+        void parentsInto(const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<Int>& fieldDestination) const;
 
         /**
          * @brief A subrange of parent indices as 32-bit integers into a pre-allocated view
@@ -1655,13 +1657,13 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @see @ref fieldSize(SceneField) const,
          *      @ref fieldObjectOffset(SceneField, UnsignedInt, std::size_t) const
          */
-        std::size_t parentsInto(std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<Int>& fieldDestination) const;
+        std::size_t parentsInto(std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<Int>& fieldDestination) const;
 
         /**
          * @brief 2D transformations as 3x3 float matrices
          * @m_since_latest
          *
-         * Convenience alternative to @ref objects(SceneField) const together
+         * Convenience alternative to @ref mapping(SceneField) const together
          * with @ref field(SceneField) const with
          * @ref SceneField::Transformation as the argument, or, if not present,
          * to a matrix created out of a subset of the
@@ -1682,17 +1684,17 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @m_since_latest
          *
          * Like @ref transformations2DAsArray(), but puts the result into
-         * @p objectDestination and @p fieldDestination instead of allocating a
-         * new array. Expects that each view is either @cpp nullptr @ce or
+         * @p mappingDestination and @p fieldDestination instead of allocating
+         * a new array. Expects that each view is either @cpp nullptr @ce or
          * sized to contain exactly all data. If @p fieldDestination is
          * @cpp nullptr @ce, the effect is the same as calling
-         * @ref objectsInto() with the first of the
+         * @ref mappingInto() with the first of the
          * @ref SceneField::Transformation, @ref SceneField::Translation,
          * @ref SceneField::Rotation and @ref SceneField::Scaling fields that's
          * present.
          * @see @ref fieldSize(SceneField) const
          */
-        void transformations2DInto(const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<Matrix3>& fieldDestination) const;
+        void transformations2DInto(const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<Matrix3>& fieldDestination) const;
 
         /**
          * @brief A subrange of 2D transformations as 3x3 float matrices into a pre-allocated view
@@ -1706,13 +1708,13 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @see @ref fieldSize(SceneField) const,
          *      @ref fieldObjectOffset(SceneField, UnsignedInt, std::size_t) const
          */
-        std::size_t transformations2DInto(std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<Matrix3>& fieldDestination) const;
+        std::size_t transformations2DInto(std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<Matrix3>& fieldDestination) const;
 
         /**
          * @brief 2D transformations as float translation, rotation and scaling components
          * @m_since_latest
          *
-         * Convenience alternative to @ref objects(SceneField) const together
+         * Convenience alternative to @ref mapping(SceneField) const together
          * with @ref field(SceneField) const with @ref SceneField::Translation,
          * @ref SceneField::Rotation and @ref SceneField::Scaling as the
          * arguments, as these are required to share the same object mapping.
@@ -1737,18 +1739,18 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @m_since_latest
          *
          * Like @ref translationsRotationsScalings2DAsArray(), but puts the
-         * result into @p objectDestination, @p translationDestination,
+         * result into @p mappingDestination, @p translationDestination,
          * @p rotationDestination and @p scalingDestination instead of
          * allocating a new array. Expects that each view is either
          * @cpp nullptr @ce or sized to contain exactly all data. If
          * @p translationDestination, @p rotationDestination and
          * @p scalingDestination are all @cpp nullptr @ce, the effect is the
-         * same as calling @ref objectsInto() with one of the
+         * same as calling @ref mappingInto() with one of the
          * @ref SceneField::Translation, @ref SceneField::Rotation and
          * @ref SceneField::Scaling fields that's present.
          * @see @ref fieldSize(SceneField) const
          */
-        void translationsRotationsScalings2DInto(const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<Vector2>& translationDestination, const Containers::StridedArrayView1D<Complex>& rotationDestination, const Containers::StridedArrayView1D<Vector2>& scalingDestination) const;
+        void translationsRotationsScalings2DInto(const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<Vector2>& translationDestination, const Containers::StridedArrayView1D<Complex>& rotationDestination, const Containers::StridedArrayView1D<Vector2>& scalingDestination) const;
 
         /**
          * @brief A subrange of 2D transformations as float translation, rotation and scaling components into a pre-allocated view
@@ -1762,13 +1764,13 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @see @ref fieldSize(SceneField) const,
          *      @ref fieldObjectOffset(SceneField, UnsignedInt, std::size_t) const
          */
-        std::size_t translationsRotationsScalings2DInto(std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<Vector2>& translationDestination, const Containers::StridedArrayView1D<Complex>& rotationDestination, const Containers::StridedArrayView1D<Vector2>& scalingDestination) const;
+        std::size_t translationsRotationsScalings2DInto(std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<Vector2>& translationDestination, const Containers::StridedArrayView1D<Complex>& rotationDestination, const Containers::StridedArrayView1D<Vector2>& scalingDestination) const;
 
         /**
          * @brief 3D transformations as 4x4 float matrices
          * @m_since_latest
          *
-         * Convenience alternative to @ref objects(SceneField) const together
+         * Convenience alternative to @ref mapping(SceneField) const together
          * with @ref field(SceneField) const with
          * @ref SceneField::Transformation as the argument, or, if not present,
          * to a matrix created out of a subset of the
@@ -1789,17 +1791,17 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @m_since_latest
          *
          * Like @ref transformations3DAsArray(), but puts the result into
-         * @p objectDestination and @p fieldDestination instead of allocating a
-         * new array. Expects that the two views are either @cpp nullptr @ce or
-         * sized to contain exactly all data. If @p fieldDestination is
+         * @p mappingDestination and @p fieldDestination instead of allocating
+         * a new array. Expects that the two views are either @cpp nullptr @ce
+         * or sized to contain exactly all data. If @p fieldDestination is
          * @cpp nullptr @ce, the effect is the same as calling
-         * @ref objectsInto() with the first of the
+         * @ref mappingInto() with the first of the
          * @ref SceneField::Transformation, @ref SceneField::Translation,
          * @ref SceneField::Rotation and @ref SceneField::Scaling fields that's
          * present.
          * @see @ref fieldSize(SceneField) const
          */
-        void transformations3DInto(const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<Matrix4>& destination) const;
+        void transformations3DInto(const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<Matrix4>& destination) const;
 
         /**
          * @brief A subrange of 3D transformations as 4x4 float matrices into a pre-allocated view
@@ -1813,13 +1815,13 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @see @ref fieldSize(SceneField) const,
          *      @ref fieldObjectOffset(SceneField, UnsignedInt, std::size_t) const
          */
-        std::size_t transformations3DInto(std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<Matrix4>& destination) const;
+        std::size_t transformations3DInto(std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<Matrix4>& destination) const;
 
         /**
          * @brief 3D transformations as float translation, rotation and scaling components
          * @m_since_latest
          *
-         * Convenience alternative to @ref objects(SceneField) const together
+         * Convenience alternative to @ref mapping(SceneField) const together
          * with @ref field(SceneField) const with @ref SceneField::Translation,
          * @ref SceneField::Rotation and @ref SceneField::Scaling as the
          * arguments, as these are required to share the same object mapping.
@@ -1844,18 +1846,18 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @m_since_latest
          *
          * Like @ref translationsRotationsScalings3DAsArray(), but puts the
-         * result into @p objectDestination, @p translationDestination,
+         * result into @p mappingDestination, @p translationDestination,
          * @p rotationDestination and @p scalingDestination instead of
          * allocating a new array. Expects that each view is either
          * @cpp nullptr @ce or sized to contain exactly all data. If
          * @p translationDestination, @p rotationDestination and
          * @p scalingDestination are all @cpp nullptr @ce, the effect is the
-         * same as calling @ref objectsInto() with one of the
+         * same as calling @ref mappingInto() with one of the
          * @ref SceneField::Translation, @ref SceneField::Rotation and
          * @ref SceneField::Scaling fields that's present.
          * @see @ref fieldSize(SceneField) const
          */
-        void translationsRotationsScalings3DInto(const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<Vector3>& translationDestination, const Containers::StridedArrayView1D<Quaternion>& rotationDestination, const Containers::StridedArrayView1D<Vector3>& scalingDestination) const;
+        void translationsRotationsScalings3DInto(const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<Vector3>& translationDestination, const Containers::StridedArrayView1D<Quaternion>& rotationDestination, const Containers::StridedArrayView1D<Vector3>& scalingDestination) const;
 
         /**
          * @brief A subrange of 3D transformations as float translation, rotation and scaling components into a pre-allocated view
@@ -1869,13 +1871,13 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @see @ref fieldSize(SceneField) const,
          *      @ref fieldObjectOffset(SceneField, UnsignedInt, std::size_t) const
          */
-        std::size_t translationsRotationsScalings3DInto(std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<Vector3>& translationDestination, const Containers::StridedArrayView1D<Quaternion>& rotationDestination, const Containers::StridedArrayView1D<Vector3>& scalingDestination) const;
+        std::size_t translationsRotationsScalings3DInto(std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<Vector3>& translationDestination, const Containers::StridedArrayView1D<Quaternion>& rotationDestination, const Containers::StridedArrayView1D<Vector3>& scalingDestination) const;
 
         /**
          * @brief Mesh and material IDs as 32-bit integers
          * @m_since_latest
          *
-         * Convenience alternative to @ref objects(SceneField) const together
+         * Convenience alternative to @ref mapping(SceneField) const together
          * with @ref field(SceneField) const with @ref SceneField::Mesh and
          * @ref SceneField::MeshMaterial as the argument, as the two are
          * required to share the same object mapping. Converts the object
@@ -1893,15 +1895,15 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @m_since_latest
          *
          * Like @ref meshesMaterialsAsArray(), but puts the results into
-         * @p objectDestination, @p meshDestination and
+         * @p mappingDestination, @p meshDestination and
          * @p meshMaterialDestination instead of allocating a new array.
          * Expects that each view is either @cpp nullptr @ce or sized to
          * contain exactly all data. If @p meshDestination and
          * @p meshMaterialDestination are both @cpp nullptr @ce, the effect is
-         * the same as calling @ref objectsInto() with @ref SceneField::Mesh.
+         * the same as calling @ref mappingInto() with @ref SceneField::Mesh.
          * @see @ref fieldSize(SceneField) const
          */
-        void meshesMaterialsInto(const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<UnsignedInt>& meshDestination, const Containers::StridedArrayView1D<Int>& meshMaterialDestination) const;
+        void meshesMaterialsInto(const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<UnsignedInt>& meshDestination, const Containers::StridedArrayView1D<Int>& meshMaterialDestination) const;
 
         /**
          * @brief A subrange of mesh and material IDs as 32-bit integers into a pre-allocated view
@@ -1915,13 +1917,13 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @see @ref fieldSize(SceneField) const,
          *      @ref fieldObjectOffset(SceneField, UnsignedInt, std::size_t) const
          */
-        std::size_t meshesMaterialsInto(std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<UnsignedInt>& meshDestination, const Containers::StridedArrayView1D<Int>& meshMaterialsDestination) const;
+        std::size_t meshesMaterialsInto(std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<UnsignedInt>& meshDestination, const Containers::StridedArrayView1D<Int>& meshMaterialsDestination) const;
 
         /**
          * @brief Light IDs as 32-bit integers
          * @m_since_latest
          *
-         * Convenience alternative to @ref objects(SceneField) const together
+         * Convenience alternative to @ref mapping(SceneField) const together
          * with @ref field(SceneField) const with @ref SceneField::Light as the
          * argument. Converts the object mapping and the field from arbitrary
          * underlying types and returns them in a newly-allocated array. The
@@ -1935,14 +1937,14 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @m_since_latest
          *
          * Like @ref lightsAsArray(), but puts the result into
-         * @p objectDestination and @p fieldDestination instead of allocating a
-         * new array. Expects that each view is either @cpp nullptr @ce or
+         * @p mappingDestination and @p fieldDestination instead of allocating
+         * a new array. Expects that each view is either @cpp nullptr @ce or
          * sized to contain exactly all data. If @p fieldDestination is
          * @cpp nullptr @ce, the effect is the same as calling
          * @ref lightsInto() with @ref SceneField::Light.
          * @see @ref fieldSize(SceneField) const
          */
-        void lightsInto(const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<UnsignedInt>& fieldDestination) const;
+        void lightsInto(const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<UnsignedInt>& fieldDestination) const;
 
         /**
          * @brief A subrange of light IDs as 32-bit integers into a pre-allocated view
@@ -1956,13 +1958,13 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @see @ref fieldSize(SceneField) const,
          *      @ref fieldObjectOffset(SceneField, UnsignedInt, std::size_t) const
          */
-        std::size_t lightsInto(std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<UnsignedInt>& fieldDestination) const;
+        std::size_t lightsInto(std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<UnsignedInt>& fieldDestination) const;
 
         /**
          * @brief Camera IDs as 32-bit integers
          * @m_since_latest
          *
-         * Convenience alternative to @ref objects(SceneField) const together
+         * Convenience alternative to @ref mapping(SceneField) const together
          * with @ref field(SceneField) const with @ref SceneField::Camera as
          * the argument. Converts the object mapping and the field from
          * arbitrary underlying types and returns them in a newly-allocated
@@ -1976,14 +1978,14 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @m_since_latest
          *
          * Like @ref camerasAsArray(), but puts the result into
-         * @p objectDestination and @p fieldDestination instead of allocating a
-         * new array. Expects that each view is either @cpp nullptr @ce or
+         * @p mappingDestination and @p fieldDestination instead of allocating
+         * a new array. Expects that each view is either @cpp nullptr @ce or
          * sized to contain exactly all data. If @p fieldDestination is
          * @cpp nullptr @ce, the effect is the same as calling
-         * @ref objectsInto() with @ref SceneField::Camera.
+         * @ref mappingInto() with @ref SceneField::Camera.
          * @see @ref fieldSize(SceneField) const
          */
-        void camerasInto(const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<UnsignedInt>& fieldDestination) const;
+        void camerasInto(const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<UnsignedInt>& fieldDestination) const;
 
         /**
          * @brief A subrange of camera IDs as 32-bit integers into a pre-allocated view
@@ -1997,13 +1999,13 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @see @ref fieldSize(SceneField) const,
          *      @ref fieldObjectOffset(SceneField, UnsignedInt, std::size_t) const
          */
-        std::size_t camerasInto(std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<UnsignedInt>& fieldDestination) const;
+        std::size_t camerasInto(std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<UnsignedInt>& fieldDestination) const;
 
         /**
          * @brief Skin IDs as 32-bit integers
          * @m_since_latest
          *
-         * Convenience alternative to @ref objects(SceneField) const together
+         * Convenience alternative to @ref mapping(SceneField) const together
          * with @ref field(SceneField) const with @ref SceneField::Skin as the
          * argument. Converts the object mapping and the field from arbitrary
          * underlying types and returns them in a newly-allocated array. The
@@ -2017,14 +2019,14 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @m_since_latest
          *
          * Like @ref skinsAsArray(), but puts the result into
-         * @p objectDestination and @p fieldDestination instead of allocating a
+         * @p mappingDestination and @p fieldDestination instead of allocating a
          * new array. Expects that each view is either @cpp nullptr @ce or
          * sized to contain exactly all data. If @p fieldDestination is
          * @cpp nullptr @ce, the effect is the same as calling
-         * @ref objectsInto() with @ref SceneField::Skin.
+         * @ref mappingInto() with @ref SceneField::Skin.
          * @see @ref fieldSize(SceneField) const
          */
-        void skinsInto(const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<UnsignedInt>& fieldDestination) const;
+        void skinsInto(const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<UnsignedInt>& fieldDestination) const;
 
         /**
          * @brief A subrange of skin IDs as 32-bit integers into a pre-allocated view
@@ -2038,13 +2040,13 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @see @ref fieldSize(SceneField) const,
          *      @ref fieldObjectOffset(SceneField, UnsignedInt, std::size_t) const
          */
-        std::size_t skinsInto(std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<UnsignedInt>& fieldDestination) const;
+        std::size_t skinsInto(std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<UnsignedInt>& fieldDestination) const;
 
         /**
          * @brief Per-object importer state as `void` pointers
          * @m_since_latest
          *
-         * Convenience alternative to @ref objects(SceneField) const together
+         * Convenience alternative to @ref mapping(SceneField) const together
          * with @ref field(SceneField) const with @ref SceneField::ImporterState
          * as the argument. Converts the object mapping and the field from
          * arbitrary underlying types and returns them in a newly-allocated
@@ -2061,14 +2063,14 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @m_since_latest
          *
          * Like @ref importerStateAsArray(), but puts the result into
-         * @p objectDestination and @p fieldDestination instead of allocating a
-         * new array. Expects that each view is either @cpp nullptr @ce or
+         * @p mappingDestination and @p fieldDestination instead of allocating
+         * a new array. Expects that each view is either @cpp nullptr @ce or
          * sized to contain exactly all data. If @p fieldDestination is
          * @cpp nullptr @ce, the effect is the same as calling
-         * @ref objectsInto() with @ref SceneField::ImporterState.
+         * @ref mappingInto() with @ref SceneField::ImporterState.
          * @see @ref fieldSize(SceneField) const
          */
-        void importerStateInto(const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<const void*>& fieldDestination) const;
+        void importerStateInto(const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<const void*>& fieldDestination) const;
 
         /**
          * @brief A subrange of per-object importer state as `void` pointers into a pre-allocated view
@@ -2082,7 +2084,7 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @see @ref fieldSize(SceneField) const,
          *      @ref fieldObjectOffset(SceneField, UnsignedInt, std::size_t) const
          */
-        std::size_t importerStateInto(std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, const Containers::StridedArrayView1D<const void*>& fieldDestination) const;
+        std::size_t importerStateInto(std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& mappingDestination, const Containers::StridedArrayView1D<const void*>& fieldDestination) const;
 
         /**
          * @brief Parent for given object
@@ -2100,7 +2102,7 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * parent for @p object, returns @ref Containers::NullOpt. If @p object
          * is top-level, returns @cpp -1 @ce.
          *
-         * The @p object is expected to be less than @ref objectCount().
+         * The @p object is expected to be less than @ref mappingBound().
          * @see @ref childrenFor()
          */
         Containers::Optional<Int> parentFor(UnsignedInt object) const;
@@ -2121,7 +2123,7 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * objects which would have @p object listed as their parent, returns
          * an empty array. Pass @cpp -1 @ce to get a list of top-level objects.
          *
-         * The @p object is expected to be less than @ref objectCount().
+         * The @p object is expected to be less than @ref mappingBound().
          * @see @ref parentFor()
          */
         Containers::Array<UnsignedInt> childrenFor(Int object) const;
@@ -2147,7 +2149,7 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * 3D transformation or there's no transformation for @p object,
          * returns @ref Containers::NullOpt.
          *
-         * The @p object is expected to be less than @ref objectCount().
+         * The @p object is expected to be less than @ref mappingBound().
          * @see @ref translationRotationScaling2DFor()
          */
         Containers::Optional<Matrix3> transformation2DFor(UnsignedInt object) const;
@@ -2176,7 +2178,7 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * there's no transformation for @p object, returns
          * @ref Containers::NullOpt.
          *
-         * The @p object is expected to be less than @ref objectCount().
+         * The @p object is expected to be less than @ref mappingBound().
          * @see @ref transformation2DFor()
          */
         Containers::Optional<Containers::Triple<Vector2, Complex, Vector2>> translationRotationScaling2DFor(UnsignedInt object) const;
@@ -2202,7 +2204,7 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * 2D transformation or there's no transformation for @p object,
          * returns @ref Containers::NullOpt.
          *
-         * The @p object is expected to be less than @ref objectCount().
+         * The @p object is expected to be less than @ref mappingBound().
          * @see @ref translationRotationScaling3DFor()
          */
         Containers::Optional<Matrix4> transformation3DFor(UnsignedInt object) const;
@@ -2231,7 +2233,7 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * there's no transformation for @p object, returns
          * @ref Containers::NullOpt.
          *
-         * The @p object is expected to be less than @ref objectCount().
+         * The @p object is expected to be less than @ref mappingBound().
          * @see @ref transformation3DFor()
          */
         Containers::Optional<Containers::Triple<Vector3, Quaternion, Vector3>> translationRotationScaling3DFor(UnsignedInt object) const;
@@ -2254,7 +2256,7 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * @ref SceneField::Mesh is not present or if there's no mesh for
          * @p object, returns an empty array.
          *
-         * The @p object is expected to be less than @ref objectCount().
+         * The @p object is expected to be less than @ref mappingBound().
          */
         Containers::Array<Containers::Pair<UnsignedInt, Int>> meshesMaterialsFor(UnsignedInt object) const;
 
@@ -2272,7 +2274,7 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * If the @ref SceneField::Light field is not present or if there's no
          * light for @p object, returns an empty array.
          *
-         * The @p object is expected to be less than @ref objectCount().
+         * The @p object is expected to be less than @ref mappingBound().
          */
         Containers::Array<UnsignedInt> lightsFor(UnsignedInt object) const;
 
@@ -2291,7 +2293,7 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * If the @ref SceneField::Camera field is not present or if there's no
          * camera for @p object, returns an empty array.
          *
-         * The @p object is expected to be less than @ref objectCount().
+         * The @p object is expected to be less than @ref mappingBound().
          */
         Containers::Array<UnsignedInt> camerasFor(UnsignedInt object) const;
 
@@ -2309,7 +2311,7 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * If the @ref SceneField::Skin field is not present or if there's no
          * skin for @p object, returns an empty array.
          *
-         * The @p object is expected to be less than @ref objectCount().
+         * The @p object is expected to be less than @ref mappingBound().
          */
         Containers::Array<UnsignedInt> skinsFor(UnsignedInt object) const;
 
@@ -2329,7 +2331,7 @@ class MAGNUM_TRADE_EXPORT SceneData {
          * there's no importer state for @p object, returns
          * @ref Containers::NullOpt.
          *
-         * The @p object is expected to be less than @ref objectCount().
+         * The @p object is expected to be less than @ref mappingBound().
          */
         Containers::Optional<const void*> importerStateFor(UnsignedInt object) const;
 
@@ -2407,14 +2409,14 @@ class MAGNUM_TRADE_EXPORT SceneData {
 
         /* Returns the offset at which `object` is for field at index `id`, or
            the end offset if the object is not found. The returned offset can
-           be then passed to fieldData{Object,Field}ViewInternal(). */
+           be then passed to fieldData{Mapping,Field}ViewInternal(). */
         MAGNUM_TRADE_LOCAL std::size_t findFieldObjectOffsetInternal(const SceneFieldData& field, UnsignedInt object, std::size_t offset) const;
 
         /* Like objects() / field(), but returning just a 1D view, sliced from
            offset to offset + size. The parameterless overloads are equal to
            offset = 0 and size = field.size(). */
-        MAGNUM_TRADE_LOCAL Containers::StridedArrayView1D<const void> fieldDataObjectViewInternal(const SceneFieldData& field, std::size_t offset, std::size_t size) const;
-        MAGNUM_TRADE_LOCAL Containers::StridedArrayView1D<const void> fieldDataObjectViewInternal(const SceneFieldData& field) const;
+        MAGNUM_TRADE_LOCAL Containers::StridedArrayView1D<const void> fieldDataMappingViewInternal(const SceneFieldData& field, std::size_t offset, std::size_t size) const;
+        MAGNUM_TRADE_LOCAL Containers::StridedArrayView1D<const void> fieldDataMappingViewInternal(const SceneFieldData& field) const;
         MAGNUM_TRADE_LOCAL Containers::StridedArrayView1D<const void> fieldDataFieldViewInternal(const SceneFieldData& field, std::size_t offset, std::size_t size) const;
         MAGNUM_TRADE_LOCAL Containers::StridedArrayView1D<const void> fieldDataFieldViewInternal(const SceneFieldData& field) const;
 
@@ -2422,7 +2424,7 @@ class MAGNUM_TRADE_EXPORT SceneData {
         template<class T> bool checkFieldTypeCompatibility(const SceneFieldData& attribute, const char* prefix) const;
         #endif
 
-        MAGNUM_TRADE_LOCAL void objectsIntoInternal(UnsignedInt fieldId, std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& destination) const;
+        MAGNUM_TRADE_LOCAL void mappingIntoInternal(UnsignedInt fieldId, std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& destination) const;
         MAGNUM_TRADE_LOCAL void parentsIntoInternal(UnsignedInt fieldId, std::size_t offset, const Containers::StridedArrayView1D<Int>& destination) const;
         MAGNUM_TRADE_LOCAL UnsignedInt findTransformFields(UnsignedInt& transformationFieldId, UnsignedInt& translationFieldId, UnsignedInt& rotationFieldId, UnsignedInt& scalingFieldId) const;
         MAGNUM_TRADE_LOCAL UnsignedInt findTranslationRotationScalingFields(UnsignedInt& translationFieldId, UnsignedInt& rotationFieldId, UnsignedInt& scalingFieldId) const;
@@ -2437,10 +2439,10 @@ class MAGNUM_TRADE_EXPORT SceneData {
         MAGNUM_TRADE_LOCAL void importerStateIntoInternal(const UnsignedInt fieldId, std::size_t offset, const Containers::StridedArrayView1D<const void*>& destination) const;
 
         DataFlags _dataFlags;
-        SceneObjectType _objectType;
+        SceneMappingType _mappingType;
         UnsignedByte _dimensions;
         /* 1/5 bytes free */
-        UnsignedLong _objectCount;
+        UnsignedLong _mappingBound;
         const void* _importerState;
         Containers::Array<SceneFieldData> _fields;
         Containers::Array<char> _data;
@@ -2569,13 +2571,13 @@ namespace Implementation {
         }
     };
 
-    template<class T> constexpr SceneObjectType sceneObjectTypeFor() {
-        static_assert(sizeof(T) == 0, "unsupported object type");
+    template<class T> constexpr SceneMappingType sceneMappingTypeFor() {
+        static_assert(sizeof(T) == 0, "unsupported mapping type");
         return {};
     }
     #ifndef DOXYGEN_GENERATING_OUTPUT
     #define _c(type) \
-        template<> constexpr SceneObjectType sceneObjectTypeFor<type>() { return SceneObjectType::type; }
+        template<> constexpr SceneMappingType sceneMappingTypeFor<type>() { return SceneMappingType::type; }
     _c(UnsignedByte)
     _c(UnsignedShort)
     _c(UnsignedInt)
@@ -2638,16 +2640,16 @@ namespace Implementation {
     }
 }
 
-constexpr SceneFieldData::SceneFieldData(const SceneField name, const SceneObjectType objectType, const Containers::StridedArrayView1D<const void>& objectData, const SceneFieldType fieldType, const Containers::StridedArrayView1D<const void>& fieldData, const UnsignedShort fieldArraySize) noexcept:
-    _size{(CORRADE_CONSTEXPR_ASSERT(objectData.size() == fieldData.size(),
-        "Trade::SceneFieldData: expected object and field view to have the same size but got" << objectData.size() << "and" << fieldData.size()), objectData.size())},
+constexpr SceneFieldData::SceneFieldData(const SceneField name, const SceneMappingType mappingType, const Containers::StridedArrayView1D<const void>& mappingData, const SceneFieldType fieldType, const Containers::StridedArrayView1D<const void>& fieldData, const UnsignedShort fieldArraySize) noexcept:
+    _size{(CORRADE_CONSTEXPR_ASSERT(mappingData.size() == fieldData.size(),
+        "Trade::SceneFieldData: expected mapping and field view to have the same size but got" << mappingData.size() << "and" << fieldData.size()), mappingData.size())},
     _name{(CORRADE_CONSTEXPR_ASSERT(Implementation::isSceneFieldTypeCompatibleWithField(name, fieldType),
         "Trade::SceneFieldData:" << fieldType << "is not a valid type for" << name), name)},
     _isOffsetOnly{false},
-    _objectType{objectType},
-    _objectStride{(CORRADE_CONSTEXPR_ASSERT(objectData.stride() >= -32768 && objectData.stride() <= 32767,
-        "Trade::SceneFieldData: expected object view stride to fit into 16 bits, but got" << objectData.stride()), Short(objectData.stride()))},
-    _objectData{objectData.data()},
+    _mappingType{mappingType},
+    _mappingStride{(CORRADE_CONSTEXPR_ASSERT(mappingData.stride() >= -32768 && mappingData.stride() <= 32767,
+        "Trade::SceneFieldData: expected mapping view stride to fit into 16 bits, but got" << mappingData.stride()), Short(mappingData.stride()))},
+    _mappingData{mappingData.data()},
     _fieldType{fieldType},
     _fieldStride{(CORRADE_CONSTEXPR_ASSERT(fieldData.stride() >= -32768 && fieldData.stride() <= 32767,
         "Trade::SceneFieldData: expected field view stride to fit into 16 bits, but got" << fieldData.stride()), Short(fieldData.stride()))},
@@ -2655,27 +2657,27 @@ constexpr SceneFieldData::SceneFieldData(const SceneField name, const SceneObjec
         "Trade::SceneFieldData:" << name << "can't be an array field"), fieldArraySize)},
     _fieldData{fieldData.data()} {}
 
-template<class T, class U> constexpr SceneFieldData::SceneFieldData(const SceneField name, const Containers::StridedArrayView1D<T>& objectData, const Containers::StridedArrayView1D<U>& fieldData) noexcept: SceneFieldData{name, Implementation::sceneObjectTypeFor<typename std::remove_const<T>::type>(), objectData, Implementation::SceneFieldTypeFor<typename std::remove_const<U>::type>::type(), fieldData, 0} {}
+template<class T, class U> constexpr SceneFieldData::SceneFieldData(const SceneField name, const Containers::StridedArrayView1D<T>& mappingData, const Containers::StridedArrayView1D<U>& fieldData) noexcept: SceneFieldData{name, Implementation::sceneMappingTypeFor<typename std::remove_const<T>::type>(), mappingData, Implementation::SceneFieldTypeFor<typename std::remove_const<U>::type>::type(), fieldData, 0} {}
 
-template<class T, class U> constexpr SceneFieldData::SceneFieldData(const SceneField name, const Containers::StridedArrayView1D<T>& objectData, const Containers::StridedArrayView2D<U>& fieldData) noexcept: SceneFieldData{
+template<class T, class U> constexpr SceneFieldData::SceneFieldData(const SceneField name, const Containers::StridedArrayView1D<T>& mappingData, const Containers::StridedArrayView2D<U>& fieldData) noexcept: SceneFieldData{
     name,
-    Implementation::sceneObjectTypeFor<typename std::remove_const<T>::type>(),
-    objectData,
+    Implementation::sceneMappingTypeFor<typename std::remove_const<T>::type>(),
+    mappingData,
     Implementation::SceneFieldTypeFor<typename std::remove_const<U>::type>::type(),
     Containers::StridedArrayView1D<const void>{{fieldData.data(), ~std::size_t{}}, fieldData.size()[0], fieldData.stride()[0]},
     /* Not using isContiguous<1>() as that's not constexpr */
     (CORRADE_CONSTEXPR_ASSERT(fieldData.stride()[1] == sizeof(U), "Trade::SceneFieldData: second field view dimension is not contiguous"), UnsignedShort(fieldData.size()[1]))
 } {}
 
-constexpr SceneFieldData::SceneFieldData(const SceneField name, const std::size_t size, const SceneObjectType objectType, const std::size_t objectOffset, const std::ptrdiff_t objectStride, const SceneFieldType fieldType, const std::size_t fieldOffset, const std::ptrdiff_t fieldStride, const UnsignedShort fieldArraySize) noexcept:
+constexpr SceneFieldData::SceneFieldData(const SceneField name, const std::size_t size, const SceneMappingType mappingType, const std::size_t mappingOffset, const std::ptrdiff_t mappingStride, const SceneFieldType fieldType, const std::size_t fieldOffset, const std::ptrdiff_t fieldStride, const UnsignedShort fieldArraySize) noexcept:
     _size{size},
     _name{(CORRADE_CONSTEXPR_ASSERT(Implementation::isSceneFieldTypeCompatibleWithField(name, fieldType),
         "Trade::SceneFieldData:" << fieldType << "is not a valid type for" << name), name)},
     _isOffsetOnly{true},
-    _objectType{objectType},
-    _objectStride{(CORRADE_CONSTEXPR_ASSERT(objectStride >= -32768 && objectStride <= 32767,
-        "Trade::SceneFieldData: expected object view stride to fit into 16 bits, but got" << objectStride), Short(objectStride))},
-    _objectData{objectOffset},
+    _mappingType{mappingType},
+    _mappingStride{(CORRADE_CONSTEXPR_ASSERT(mappingStride >= -32768 && mappingStride <= 32767,
+        "Trade::SceneFieldData: expected mapping view stride to fit into 16 bits, but got" << mappingStride), Short(mappingStride))},
+    _mappingData{mappingOffset},
     _fieldType{fieldType},
     _fieldStride{(CORRADE_CONSTEXPR_ASSERT(fieldStride >= -32768 && fieldStride <= 32767,
         "Trade::SceneFieldData: expected field view stride to fit into 16 bits, but got" << fieldStride), Short(fieldStride))},
@@ -2683,43 +2685,43 @@ constexpr SceneFieldData::SceneFieldData(const SceneField name, const std::size_
         "Trade::SceneFieldData:" << name << "can't be an array field"), fieldArraySize)},
     _fieldData{fieldOffset} {}
 
-template<class T> Containers::StridedArrayView1D<const T> SceneData::objects(const UnsignedInt fieldId) const {
-    Containers::StridedArrayView2D<const char> data = objects(fieldId);
+template<class T> Containers::StridedArrayView1D<const T> SceneData::mapping(const UnsignedInt fieldId) const {
+    Containers::StridedArrayView2D<const char> data = mapping(fieldId);
     #ifdef CORRADE_GRACEFUL_ASSERT /* Sigh. Brittle. Better idea? */
     if(!data.stride()[1]) return {};
     #endif
-    CORRADE_ASSERT(Implementation::sceneObjectTypeFor<T>() == _objectType,
-        "Trade::SceneData::objects(): objects are" << _objectType << "but requested" << Implementation::sceneObjectTypeFor<T>(), {});
+    CORRADE_ASSERT(Implementation::sceneMappingTypeFor<T>() == _mappingType,
+        "Trade::SceneData::mapping(): mapping is" << _mappingType << "but requested" << Implementation::sceneMappingTypeFor<T>(), {});
     return Containers::arrayCast<1, const T>(data);
 }
 
-template<class T> Containers::StridedArrayView1D<T> SceneData::mutableObjects(const UnsignedInt fieldId) {
-    Containers::StridedArrayView2D<char> data = mutableObjects(fieldId);
+template<class T> Containers::StridedArrayView1D<T> SceneData::mutableMapping(const UnsignedInt fieldId) {
+    Containers::StridedArrayView2D<char> data = mutableMapping(fieldId);
     #ifdef CORRADE_GRACEFUL_ASSERT /* Sigh. Brittle. Better idea? */
     if(!data.stride()[1]) return {};
     #endif
-    CORRADE_ASSERT(Implementation::sceneObjectTypeFor<T>() == _objectType,
-        "Trade::SceneData::mutableObjects(): objects are" << _objectType << "but requested" << Implementation::sceneObjectTypeFor<T>(), {});
+    CORRADE_ASSERT(Implementation::sceneMappingTypeFor<T>() == _mappingType,
+        "Trade::SceneData::mutableMapping(): mapping is" << _mappingType << "but requested" << Implementation::sceneMappingTypeFor<T>(), {});
     return Containers::arrayCast<1, T>(data);
 }
 
-template<class T> Containers::StridedArrayView1D<const T> SceneData::objects(const SceneField fieldName) const {
-    Containers::StridedArrayView2D<const char> data = objects(fieldName);
+template<class T> Containers::StridedArrayView1D<const T> SceneData::mapping(const SceneField fieldName) const {
+    Containers::StridedArrayView2D<const char> data = mapping(fieldName);
     #ifdef CORRADE_GRACEFUL_ASSERT /* Sigh. Brittle. Better idea? */
     if(!data.stride()[1]) return {};
     #endif
-    CORRADE_ASSERT(Implementation::sceneObjectTypeFor<T>() == _objectType,
-        "Trade::SceneData::objects(): objects are" << _objectType << "but requested" << Implementation::sceneObjectTypeFor<T>(), {});
+    CORRADE_ASSERT(Implementation::sceneMappingTypeFor<T>() == _mappingType,
+        "Trade::SceneData::mapping(): mapping is" << _mappingType << "but requested" << Implementation::sceneMappingTypeFor<T>(), {});
     return Containers::arrayCast<1, const T>(data);
 }
 
-template<class T> Containers::StridedArrayView1D<T> SceneData::mutableObjects(const SceneField fieldName) {
-    Containers::StridedArrayView2D<char> data = mutableObjects(fieldName);
+template<class T> Containers::StridedArrayView1D<T> SceneData::mutableMapping(const SceneField fieldName) {
+    Containers::StridedArrayView2D<char> data = mutableMapping(fieldName);
     #ifdef CORRADE_GRACEFUL_ASSERT /* Sigh. Brittle. Better idea? */
     if(!data.stride()[1]) return {};
     #endif
-    CORRADE_ASSERT(Implementation::sceneObjectTypeFor<T>() == _objectType,
-        "Trade::SceneData::mutableObjects(): objects are" << _objectType << "but requested" << Implementation::sceneObjectTypeFor<T>(), {});
+    CORRADE_ASSERT(Implementation::sceneMappingTypeFor<T>() == _mappingType,
+        "Trade::SceneData::mutableMapping(): mapping is" << _mappingType << "but requested" << Implementation::sceneMappingTypeFor<T>(), {});
     return Containers::arrayCast<1, T>(data);
 }
 
diff --git a/src/Magnum/Trade/Test/AbstractImporterTest.cpp b/src/Magnum/Trade/Test/AbstractImporterTest.cpp
index 3c6bfc948..836f46417 100644
--- a/src/Magnum/Trade/Test/AbstractImporterTest.cpp
+++ b/src/Magnum/Trade/Test/AbstractImporterTest.cpp
@@ -1703,8 +1703,8 @@ void AbstractImporterTest::scene() {
         }
         Containers::Optional<SceneData> doScene(UnsignedInt id) override {
             if(id == 7)
-                return SceneData{SceneObjectType::UnsignedByte, 0, nullptr, {}, &state};
-            return SceneData{SceneObjectType::UnsignedByte, 0, nullptr, {}};
+                return SceneData{SceneMappingType::UnsignedByte, 0, nullptr, {}, &state};
+            return SceneData{SceneMappingType::UnsignedByte, 0, nullptr, {}};
         }
     } importer;
 
@@ -1899,21 +1899,21 @@ void AbstractImporterTest::sceneDeprecatedFallback2D() {
             /* This one has seven objects, but no fields for them so it should
                get skipped */
             if(id == 0)
-                return SceneData{SceneObjectType::UnsignedByte, 7, nullptr, {}};
+                return SceneData{SceneMappingType::UnsignedByte, 7, nullptr, {}};
             /* This one has no objects, so it should get skipped as well
                without even querying any fieldFor() API (as those would
                assert) */
             if(id == 1)
-                return SceneData{SceneObjectType::UnsignedShort, 0, nullptr, {}};
+                return SceneData{SceneMappingType::UnsignedShort, 0, nullptr, {}};
             /* This one is the one */
             if(id == 2)
-                return SceneData{SceneObjectType::UnsignedInt, 7, {}, _data.data(), sceneFieldDataNonOwningArray(_data.fieldData())};
+                return SceneData{SceneMappingType::UnsignedInt, 7, {}, _data.data(), sceneFieldDataNonOwningArray(_data.fieldData())};
             CORRADE_INTERNAL_ASSERT_UNREACHABLE();
         }
 
         private:
             SceneData _data;
-    } importer{SceneData{SceneObjectType::UnsignedInt, 7, std::move(data), {
+    } importer{SceneData{SceneMappingType::UnsignedInt, 7, std::move(data), {
         SceneFieldData{SceneField::Parent,
             transformations.slice(&Transform::object),
             transformations.slice(&Transform::parent)},
@@ -2171,21 +2171,21 @@ void AbstractImporterTest::sceneDeprecatedFallback3D() {
             /* This one has seven objects, but no fields for them so it should
                get skipped */
             if(id == 0)
-                return SceneData{SceneObjectType::UnsignedByte, 7, nullptr, {}};
+                return SceneData{SceneMappingType::UnsignedByte, 7, nullptr, {}};
             /* This one has no objects, so it should get skipped as well
                without even querying any fieldFor() API (as those would
                assert) */
             if(id == 1)
-                return SceneData{SceneObjectType::UnsignedShort, 0, nullptr, {}};
+                return SceneData{SceneMappingType::UnsignedShort, 0, nullptr, {}};
             /* This one is the one */
             if(id == 2)
-                return SceneData{SceneObjectType::UnsignedInt, 7, {}, _data.data(), sceneFieldDataNonOwningArray(_data.fieldData())};
+                return SceneData{SceneMappingType::UnsignedInt, 7, {}, _data.data(), sceneFieldDataNonOwningArray(_data.fieldData())};
             CORRADE_INTERNAL_ASSERT_UNREACHABLE();
         }
 
         private:
             SceneData _data;
-    } importer{SceneData{SceneObjectType::UnsignedInt, 7, std::move(data), {
+    } importer{SceneData{SceneMappingType::UnsignedInt, 7, std::move(data), {
         SceneFieldData{SceneField::Parent,
             transformations.slice(&Transform::object),
             transformations.slice(&Transform::parent)},
@@ -2356,12 +2356,12 @@ void AbstractImporterTest::sceneDeprecatedFallbackParentless2D() {
         UnsignedInt doSceneCount() const override { return 1; }
         UnsignedLong doObjectCount() const override { return 6; }
         Containers::Optional<SceneData> doScene(UnsignedInt) override {
-            return SceneData{SceneObjectType::UnsignedInt, 6, {}, _data.data(), sceneFieldDataNonOwningArray(_data.fieldData())};
+            return SceneData{SceneMappingType::UnsignedInt, 6, {}, _data.data(), sceneFieldDataNonOwningArray(_data.fieldData())};
         }
 
         private:
             SceneData _data;
-    } importer{SceneData{SceneObjectType::UnsignedInt, 6, {}, fields, {
+    } importer{SceneData{SceneMappingType::UnsignedInt, 6, {}, fields, {
         SceneFieldData{SceneField::Transformation,
             view.slice(&Field::object),
             view.slice(&Field::transformation)}
@@ -2431,12 +2431,12 @@ void AbstractImporterTest::sceneDeprecatedFallbackParentless3D() {
         UnsignedInt doSceneCount() const override { return 1; }
         UnsignedLong doObjectCount() const override { return 6; }
         Containers::Optional<SceneData> doScene(UnsignedInt) override {
-            return SceneData{SceneObjectType::UnsignedInt, 6, {}, _data.data(), sceneFieldDataNonOwningArray(_data.fieldData())};
+            return SceneData{SceneMappingType::UnsignedInt, 6, {}, _data.data(), sceneFieldDataNonOwningArray(_data.fieldData())};
         }
 
         private:
             SceneData _data;
-    } importer{SceneData{SceneObjectType::UnsignedInt, 6, {}, fields, {
+    } importer{SceneData{SceneMappingType::UnsignedInt, 6, {}, fields, {
         SceneFieldData{SceneField::Transformation,
             view.slice(&Field::object),
             view.slice(&Field::transformation)}
@@ -2506,17 +2506,17 @@ void AbstractImporterTest::sceneDeprecatedFallbackTransformless2D() {
         UnsignedInt doSceneCount() const override { return 1; }
         UnsignedLong doObjectCount() const override { return 6; }
         Containers::Optional<SceneData> doScene(UnsignedInt) override {
-            return SceneData{SceneObjectType::UnsignedInt, 6, {}, _data.data(), sceneFieldDataNonOwningArray(_data.fieldData())};
+            return SceneData{SceneMappingType::UnsignedInt, 6, {}, _data.data(), sceneFieldDataNonOwningArray(_data.fieldData())};
         }
 
         private:
             SceneData _data;
-    } importer{SceneData{SceneObjectType::UnsignedInt, 6, {}, fields, {
+    } importer{SceneData{SceneMappingType::UnsignedInt, 6, {}, fields, {
         SceneFieldData{SceneField::Parent,
             view.slice(&Field::object),
             view.slice(&Field::parent)},
         /* Required in order to have the scene recognized as 2D */
-        SceneFieldData{SceneField::Transformation, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Matrix3x3, nullptr}
+        SceneFieldData{SceneField::Transformation, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Matrix3x3, nullptr}
     }}};
 
     CORRADE_COMPARE(importer.sceneCount(), 1);
@@ -2612,17 +2612,17 @@ void AbstractImporterTest::sceneDeprecatedFallbackTransformless3D() {
         UnsignedInt doSceneCount() const override { return 1; }
         UnsignedLong doObjectCount() const override { return 6; }
         Containers::Optional<SceneData> doScene(UnsignedInt) override {
-            return SceneData{SceneObjectType::UnsignedInt, 6, {}, _data.data(), sceneFieldDataNonOwningArray(_data.fieldData())};
+            return SceneData{SceneMappingType::UnsignedInt, 6, {}, _data.data(), sceneFieldDataNonOwningArray(_data.fieldData())};
         }
 
         private:
             SceneData _data;
-    } importer{SceneData{SceneObjectType::UnsignedInt, 6, {}, fields, {
+    } importer{SceneData{SceneMappingType::UnsignedInt, 6, {}, fields, {
         SceneFieldData{SceneField::Parent,
             view.slice(&Field::object),
             view.slice(&Field::parent)},
         /* Required in order to have the scene recognized as 3D */
-        SceneFieldData{SceneField::Transformation, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Matrix4x4, nullptr}
+        SceneFieldData{SceneField::Transformation, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Matrix4x4, nullptr}
     }}};
 
     CORRADE_COMPARE(importer.sceneCount(), 1);
@@ -2747,20 +2747,20 @@ void AbstractImporterTest::sceneDeprecatedFallbackMultiFunctionObjects2D() {
         {30, 1, -1}
     }, meshesSecondary);
 
-    SceneData data{SceneObjectType::UnsignedInt, 32, std::move(dataData), {
+    SceneData data{SceneMappingType::UnsignedInt, 32, std::move(dataData), {
         SceneFieldData{SceneField::Parent, parents.slice(&Parent::object), parents.slice(&Parent::parent)},
         SceneFieldData{SceneField::Mesh, meshes.slice(&Mesh::object), meshes.slice(&Mesh::mesh)},
         SceneFieldData{SceneField::MeshMaterial, meshes.slice(&Mesh::object), meshes.slice(&Mesh::meshMaterial)},
         SceneFieldData{SceneField::Camera, cameras.slice(&Camera::object), cameras.slice(&Camera::camera)},
         /* Just to disambiguate this as a 2D scene */
-        SceneFieldData{SceneField::Transformation, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Matrix3x3, nullptr},
+        SceneFieldData{SceneField::Transformation, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Matrix3x3, nullptr},
     }};
-    SceneData dataSecondary{SceneObjectType::UnsignedInt, 31, std::move(dataDataSecondary), {
+    SceneData dataSecondary{SceneMappingType::UnsignedInt, 31, std::move(dataDataSecondary), {
         SceneFieldData{SceneField::Parent, parentsSecondary.slice(&Parent::object), parentsSecondary.slice(&Parent::parent)},
         SceneFieldData{SceneField::Mesh, meshesSecondary.slice(&Mesh::object), meshesSecondary.slice(&Mesh::mesh)},
         SceneFieldData{SceneField::MeshMaterial, meshesSecondary.slice(&Mesh::object), meshesSecondary.slice(&Mesh::meshMaterial)},
         /* Just to disambiguate this as a 2D scene */
-        SceneFieldData{SceneField::Transformation, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Matrix3x3, nullptr},
+        SceneFieldData{SceneField::Transformation, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Matrix3x3, nullptr},
     }};
 
     struct Importer: AbstractImporter {
@@ -2784,19 +2784,19 @@ void AbstractImporterTest::sceneDeprecatedFallbackMultiFunctionObjects2D() {
             /* This scene should get skipped when querying names as it's not
                2D */
             if(id == 0)
-                return SceneData{SceneObjectType::UnsignedByte, 32, nullptr, {}};
+                return SceneData{SceneMappingType::UnsignedByte, 32, nullptr, {}};
             /* This scene should get skipped when querying names as it has too
                little objects */
             if(id == 1)
-                return SceneData{SceneObjectType::UnsignedByte, 32, nullptr, {
-                    SceneFieldData{SceneField::Transformation, SceneObjectType::UnsignedByte, nullptr, SceneFieldType::Matrix3x3, nullptr}
+                return SceneData{SceneMappingType::UnsignedByte, 32, nullptr, {
+                    SceneFieldData{SceneField::Transformation, SceneMappingType::UnsignedByte, nullptr, SceneFieldType::Matrix3x3, nullptr}
                 }};
             if(id == 2)
-                return SceneData{SceneObjectType::UnsignedInt, 32, {}, _data.data(), sceneFieldDataNonOwningArray(_data.fieldData())};
+                return SceneData{SceneMappingType::UnsignedInt, 32, {}, _data.data(), sceneFieldDataNonOwningArray(_data.fieldData())};
             /* A secondary scene, which should have non-overlapping IDs for the
                newly added objects */
             if(id == 3)
-                return SceneData{SceneObjectType::UnsignedInt, 31, {}, _dataSecondary.data(), sceneFieldDataNonOwningArray(_dataSecondary.fieldData())};
+                return SceneData{SceneMappingType::UnsignedInt, 31, {}, _dataSecondary.data(), sceneFieldDataNonOwningArray(_dataSecondary.fieldData())};
             CORRADE_INTERNAL_ASSERT_UNREACHABLE();
         }
 
@@ -3014,20 +3014,20 @@ void AbstractImporterTest::sceneDeprecatedFallbackMultiFunctionObjects3D() {
         {30, 1, -1}
     }, meshesSecondary);
 
-    SceneData data{SceneObjectType::UnsignedInt, 32, std::move(dataData), {
+    SceneData data{SceneMappingType::UnsignedInt, 32, std::move(dataData), {
         SceneFieldData{SceneField::Parent, parents.slice(&Parent::object), parents.slice(&Parent::parent)},
         SceneFieldData{SceneField::Mesh, meshes.slice(&Mesh::object), meshes.slice(&Mesh::mesh)},
         SceneFieldData{SceneField::MeshMaterial, meshes.slice(&Mesh::object), meshes.slice(&Mesh::meshMaterial)},
         SceneFieldData{SceneField::Camera, cameras.slice(&Camera::object), cameras.slice(&Camera::camera)},
         /* Just to disambiguate this as a 3D scene */
-        SceneFieldData{SceneField::Transformation, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Matrix4x4, nullptr},
+        SceneFieldData{SceneField::Transformation, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Matrix4x4, nullptr},
     }};
-    SceneData dataSecondary{SceneObjectType::UnsignedInt, 31, std::move(dataDataSecondary), {
+    SceneData dataSecondary{SceneMappingType::UnsignedInt, 31, std::move(dataDataSecondary), {
         SceneFieldData{SceneField::Parent, parentsSecondary.slice(&Parent::object), parentsSecondary.slice(&Parent::parent)},
         SceneFieldData{SceneField::Mesh, meshesSecondary.slice(&Mesh::object), meshesSecondary.slice(&Mesh::mesh)},
         SceneFieldData{SceneField::MeshMaterial, meshesSecondary.slice(&Mesh::object), meshesSecondary.slice(&Mesh::meshMaterial)},
         /* Just to disambiguate this as a 3D scene */
-        SceneFieldData{SceneField::Transformation, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Matrix4x4, nullptr},
+        SceneFieldData{SceneField::Transformation, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Matrix4x4, nullptr},
     }};
 
     struct Importer: AbstractImporter {
@@ -3051,19 +3051,19 @@ void AbstractImporterTest::sceneDeprecatedFallbackMultiFunctionObjects3D() {
             /* This scene should get skipped when querying names as it's not
                2D */
             if(id == 0)
-                return SceneData{SceneObjectType::UnsignedByte, 32, nullptr, {}};
+                return SceneData{SceneMappingType::UnsignedByte, 32, nullptr, {}};
             /* This scene should get skipped when querying names as it has too
                little objects */
             if(id == 1)
-                return SceneData{SceneObjectType::UnsignedByte, 32, nullptr, {
-                    SceneFieldData{SceneField::Transformation, SceneObjectType::UnsignedByte, nullptr, SceneFieldType::Matrix4x4, nullptr}
+                return SceneData{SceneMappingType::UnsignedByte, 32, nullptr, {
+                    SceneFieldData{SceneField::Transformation, SceneMappingType::UnsignedByte, nullptr, SceneFieldType::Matrix4x4, nullptr}
                 }};
             if(id == 2)
-                return SceneData{SceneObjectType::UnsignedInt, 32, {}, _data.data(), sceneFieldDataNonOwningArray(_data.fieldData())};
+                return SceneData{SceneMappingType::UnsignedInt, 32, {}, _data.data(), sceneFieldDataNonOwningArray(_data.fieldData())};
             /* A secondary scene, which should have non-overlapping IDs for the
                newly added objects */
             if(id == 3)
-                return SceneData{SceneObjectType::UnsignedInt, 31, {}, _dataSecondary.data(), sceneFieldDataNonOwningArray(_dataSecondary.fieldData())};
+                return SceneData{SceneMappingType::UnsignedInt, 31, {}, _dataSecondary.data(), sceneFieldDataNonOwningArray(_dataSecondary.fieldData())};
             CORRADE_INTERNAL_ASSERT_UNREACHABLE();
         }
 
@@ -3282,13 +3282,13 @@ void AbstractImporterTest::sceneDeprecatedFallbackBoth2DAnd3DScene() {
             return {};
         }
         Containers::Optional<SceneData> doScene(UnsignedInt id) override {
-            if(id == 0) return SceneData{SceneObjectType::UnsignedInt, 7, nullptr, {
-                SceneFieldData{SceneField::Parent, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
-                SceneFieldData{SceneField::Translation, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Vector2, nullptr},
+            if(id == 0) return SceneData{SceneMappingType::UnsignedInt, 7, nullptr, {
+                SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
+                SceneFieldData{SceneField::Translation, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Vector2, nullptr},
             }};
-            if(id == 1) return SceneData{SceneObjectType::UnsignedInt, 7, nullptr, {
-                SceneFieldData{SceneField::Parent, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
-                SceneFieldData{SceneField::Translation, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Vector3, nullptr},
+            if(id == 1) return SceneData{SceneMappingType::UnsignedInt, 7, nullptr, {
+                SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
+                SceneFieldData{SceneField::Translation, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Vector3, nullptr},
             }};
             CORRADE_INTERNAL_ASSERT_UNREACHABLE();
         }
@@ -3432,14 +3432,14 @@ void AbstractImporterTest::sceneNonOwningDeleters() {
 
         UnsignedInt doSceneCount() const override { return 1; }
         Containers::Optional<SceneData> doScene(UnsignedInt) override {
-            return SceneData{SceneObjectType::UnsignedInt, 0,
+            return SceneData{SceneMappingType::UnsignedInt, 0,
                 Containers::Array<char>{data, 1, Implementation::nonOwnedArrayDeleter},
                 sceneFieldDataNonOwningArray(fields)};
         }
 
         char data[1];
         SceneFieldData fields[1]{
-            SceneFieldData{SceneField::Parent, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr}
+            SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr}
         };
     } importer;
 
@@ -3462,7 +3462,7 @@ void AbstractImporterTest::sceneCustomDataDeleter() {
         UnsignedInt doSceneCount() const override { return 1; }
         Int doSceneForName(const std::string&) override { return 0; }
         Containers::Optional<SceneData> doScene(UnsignedInt) override {
-            return SceneData{SceneObjectType::UnsignedInt, 0,
+            return SceneData{SceneMappingType::UnsignedInt, 0,
                 Containers::Array<char>{data, 1, [](char*, std::size_t) {}},
                 {}};
         }
@@ -3493,10 +3493,10 @@ void AbstractImporterTest::sceneCustomFieldDataDeleter() {
         UnsignedInt doSceneCount() const override { return 1; }
         Int doSceneForName(const std::string&) override { return 0; }
         Containers::Optional<SceneData> doScene(UnsignedInt) override {
-            return SceneData{SceneObjectType::UnsignedInt, 0, nullptr, Containers::Array<SceneFieldData>{&parents, 1, [](SceneFieldData*, std::size_t) {}}};
+            return SceneData{SceneMappingType::UnsignedInt, 0, nullptr, Containers::Array<SceneFieldData>{&parents, 1, [](SceneFieldData*, std::size_t) {}}};
         }
 
-        SceneFieldData parents{SceneField::Parent, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr};
+        SceneFieldData parents{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr};
     } importer;
 
     std::ostringstream out;
diff --git a/src/Magnum/Trade/Test/SceneDataTest.cpp b/src/Magnum/Trade/Test/SceneDataTest.cpp
index 20c8d190d..c3c987002 100644
--- a/src/Magnum/Trade/Test/SceneDataTest.cpp
+++ b/src/Magnum/Trade/Test/SceneDataTest.cpp
@@ -50,9 +50,9 @@ namespace Magnum { namespace Trade { namespace Test { namespace {
 struct SceneDataTest: TestSuite::Tester {
     explicit SceneDataTest();
 
-    void objectTypeSizeAlignment();
-    void objectTypeSizeAlignmentInvalid();
-    void debugObjectType();
+    void mappingTypeSizeAlignment();
+    void mappingTypeSizeAlignmentInvalid();
+    void debugMappingType();
 
     void customFieldName();
     void customFieldNameTooLarge();
@@ -77,7 +77,7 @@ struct SceneDataTest: TestSuite::Tester {
 
     void constructFieldWrongType();
     void constructFieldInconsistentViewSize();
-    void constructFieldTooLargeObjectStride();
+    void constructFieldTooLargeMappingStride();
     void constructFieldTooLargeFieldStride();
     void constructFieldWrongDataAccess();
     void constructField2DWrongSize();
@@ -99,10 +99,10 @@ struct SceneDataTest: TestSuite::Tester {
 
     void constructDuplicateField();
     void constructDuplicateCustomField();
-    void constructInconsistentObjectType();
-    void constructObjectDataNotContained();
+    void constructInconsistentMappingType();
+    void constructMappingDataNotContained();
     void constructFieldDataNotContained();
-    void constructObjectTypeTooSmall();
+    void constructMappingTypeTooSmall();
     void constructNotOwnedFlagOwned();
     void constructMismatchedTRSViews();
     template<class T> void constructMismatchedTRSDimensionality();
@@ -117,11 +117,11 @@ struct SceneDataTest: TestSuite::Tester {
     void findFieldObjectOffsetInvalidOffset();
     void fieldObjectOffsetNotFound();
 
-    template<class T> void objectsAsArrayByIndex();
-    template<class T> void objectsAsArrayByName();
-    void objectsIntoArrayByIndex();
-    void objectsIntoArrayByName();
-    void objectsIntoArrayInvalidSizeOrOffset();
+    template<class T> void mappingAsArrayByIndex();
+    template<class T> void mappingAsArrayByName();
+    void mappingIntoArrayByIndex();
+    void mappingIntoArrayByName();
+    void mappingIntoArrayInvalidSizeOrOffset();
 
     template<class T> void parentsAsArray();
     void parentsIntoArray();
@@ -160,8 +160,8 @@ struct SceneDataTest: TestSuite::Tester {
 
     void mutableAccessNotAllowed();
 
-    void objectsNotFound();
-    void objectsWrongType();
+    void mappingNotFound();
+    void mappingWrongType();
 
     void fieldNotFound();
     void fieldWrongType();
@@ -220,13 +220,13 @@ const struct {
     std::size_t offset;
     std::size_t size;
     std::size_t expectedSize;
-    bool objects, field;
+    bool mapping, field;
 } IntoArrayOffset1Data[]{
     {"whole", 0, 3, 3, true, true},
     {"one element in the middle", 1, 1, 1, true, true},
     {"suffix to a larger array", 2, 10, 1, true, true},
     {"offset at the end", 3, 10, 0, true, true},
-    {"only objects", 0, 3, 3, true, false},
+    {"only mapping", 0, 3, 3, true, false},
     {"only field", 0, 3, 3, false, true},
     {"neither", 0, 3, 0, false, false}
 };
@@ -236,13 +236,13 @@ const struct {
     std::size_t offset;
     std::size_t size;
     std::size_t expectedSize;
-    bool objects, field1, field2;
+    bool mapping, field1, field2;
 } IntoArrayOffset2Data[]{
     {"whole", 0, 3, 3, true, true, true},
     {"one element in the middle", 1, 1, 1, true, true, true},
     {"suffix to a larger array", 2, 10, 1, true, true, true},
     {"offset at the end", 3, 10, 0, true, true, true},
-    {"only objects", 0, 3, 3, true, false, false},
+    {"only mapping", 0, 3, 3, true, false, false},
     {"only fields", 0, 3, 3, false, true, true},
     {"only first field", 0, 3, 3, false, true, false},
     {"only second field", 0, 3, 3, false, false, true},
@@ -254,13 +254,13 @@ const struct {
     std::size_t offset;
     std::size_t size;
     std::size_t expectedSize;
-    bool objects, field1, field2, field3;
+    bool mapping, field1, field2, field3;
 } IntoArrayOffset3Data[]{
     {"whole", 0, 3, 3, true, true, true, true},
     {"one element in the middle", 1, 1, 1, true, true, true, true},
     {"suffix to a larger array", 2, 10, 1, true, true, true, true},
     {"offset at the end", 3, 10, 0, true, true, true, true},
-    {"only objects", 0, 3, 3, true, false, false, true},
+    {"only mapping", 0, 3, 3, true, false, false, true},
     {"only fields", 0, 3, 3, false, true, true, true},
     {"only first field", 0, 3, 3, false, true, false, false},
     {"only second field", 0, 3, 3, false, false, true, false},
@@ -285,9 +285,9 @@ const struct {
 #endif
 
 SceneDataTest::SceneDataTest() {
-    addTests({&SceneDataTest::objectTypeSizeAlignment,
-              &SceneDataTest::objectTypeSizeAlignmentInvalid,
-              &SceneDataTest::debugObjectType,
+    addTests({&SceneDataTest::mappingTypeSizeAlignment,
+              &SceneDataTest::mappingTypeSizeAlignmentInvalid,
+              &SceneDataTest::debugMappingType,
 
               &SceneDataTest::customFieldName,
               &SceneDataTest::customFieldNameTooLarge,
@@ -312,7 +312,7 @@ SceneDataTest::SceneDataTest() {
 
               &SceneDataTest::constructFieldWrongType,
               &SceneDataTest::constructFieldInconsistentViewSize,
-              &SceneDataTest::constructFieldTooLargeObjectStride,
+              &SceneDataTest::constructFieldTooLargeMappingStride,
               &SceneDataTest::constructFieldTooLargeFieldStride,
               &SceneDataTest::constructFieldWrongDataAccess,
               &SceneDataTest::constructField2DWrongSize,
@@ -339,10 +339,10 @@ SceneDataTest::SceneDataTest() {
 
     addTests({&SceneDataTest::constructDuplicateField,
               &SceneDataTest::constructDuplicateCustomField,
-              &SceneDataTest::constructInconsistentObjectType,
-              &SceneDataTest::constructObjectDataNotContained,
+              &SceneDataTest::constructInconsistentMappingType,
+              &SceneDataTest::constructMappingDataNotContained,
               &SceneDataTest::constructFieldDataNotContained,
-              &SceneDataTest::constructObjectTypeTooSmall,
+              &SceneDataTest::constructMappingTypeTooSmall,
               &SceneDataTest::constructNotOwnedFlagOwned,
               &SceneDataTest::constructMismatchedTRSViews,
               &SceneDataTest::constructMismatchedTRSDimensionality<Float>,
@@ -361,20 +361,20 @@ SceneDataTest::SceneDataTest() {
               &SceneDataTest::findFieldObjectOffsetInvalidOffset,
               &SceneDataTest::fieldObjectOffsetNotFound,
 
-              &SceneDataTest::objectsAsArrayByIndex<UnsignedByte>,
-              &SceneDataTest::objectsAsArrayByIndex<UnsignedShort>,
-              &SceneDataTest::objectsAsArrayByIndex<UnsignedInt>,
-              &SceneDataTest::objectsAsArrayByIndex<UnsignedLong>,
-              &SceneDataTest::objectsAsArrayByName<UnsignedByte>,
-              &SceneDataTest::objectsAsArrayByName<UnsignedShort>,
-              &SceneDataTest::objectsAsArrayByName<UnsignedInt>,
-              &SceneDataTest::objectsAsArrayByName<UnsignedLong>});
-
-    addInstancedTests({&SceneDataTest::objectsIntoArrayByIndex,
-                       &SceneDataTest::objectsIntoArrayByName},
+              &SceneDataTest::mappingAsArrayByIndex<UnsignedByte>,
+              &SceneDataTest::mappingAsArrayByIndex<UnsignedShort>,
+              &SceneDataTest::mappingAsArrayByIndex<UnsignedInt>,
+              &SceneDataTest::mappingAsArrayByIndex<UnsignedLong>,
+              &SceneDataTest::mappingAsArrayByName<UnsignedByte>,
+              &SceneDataTest::mappingAsArrayByName<UnsignedShort>,
+              &SceneDataTest::mappingAsArrayByName<UnsignedInt>,
+              &SceneDataTest::mappingAsArrayByName<UnsignedLong>});
+
+    addInstancedTests({&SceneDataTest::mappingIntoArrayByIndex,
+                       &SceneDataTest::mappingIntoArrayByName},
         Containers::arraySize(IntoArrayOffsetData));
 
-    addTests({&SceneDataTest::objectsIntoArrayInvalidSizeOrOffset,
+    addTests({&SceneDataTest::mappingIntoArrayInvalidSizeOrOffset,
 
               &SceneDataTest::parentsAsArray<Byte>,
               &SceneDataTest::parentsAsArray<Short>,
@@ -465,8 +465,8 @@ SceneDataTest::SceneDataTest() {
 
               &SceneDataTest::mutableAccessNotAllowed,
 
-              &SceneDataTest::objectsNotFound,
-              &SceneDataTest::objectsWrongType,
+              &SceneDataTest::mappingNotFound,
+              &SceneDataTest::mappingWrongType,
 
               &SceneDataTest::fieldNotFound,
               &SceneDataTest::fieldWrongType,
@@ -503,18 +503,18 @@ SceneDataTest::SceneDataTest() {
 
 using namespace Math::Literals;
 
-void SceneDataTest::objectTypeSizeAlignment() {
-    CORRADE_COMPARE(sceneObjectTypeSize(SceneObjectType::UnsignedByte), 1);
-    CORRADE_COMPARE(sceneObjectTypeAlignment(SceneObjectType::UnsignedByte), 1);
-    CORRADE_COMPARE(sceneObjectTypeSize(SceneObjectType::UnsignedShort), 2);
-    CORRADE_COMPARE(sceneObjectTypeAlignment(SceneObjectType::UnsignedShort), 2);
-    CORRADE_COMPARE(sceneObjectTypeSize(SceneObjectType::UnsignedInt), 4);
-    CORRADE_COMPARE(sceneObjectTypeAlignment(SceneObjectType::UnsignedInt), 4);
-    CORRADE_COMPARE(sceneObjectTypeSize(SceneObjectType::UnsignedLong), 8);
-    CORRADE_COMPARE(sceneObjectTypeAlignment(SceneObjectType::UnsignedLong), 8);
+void SceneDataTest::mappingTypeSizeAlignment() {
+    CORRADE_COMPARE(sceneMappingTypeSize(SceneMappingType::UnsignedByte), 1);
+    CORRADE_COMPARE(sceneMappingTypeAlignment(SceneMappingType::UnsignedByte), 1);
+    CORRADE_COMPARE(sceneMappingTypeSize(SceneMappingType::UnsignedShort), 2);
+    CORRADE_COMPARE(sceneMappingTypeAlignment(SceneMappingType::UnsignedShort), 2);
+    CORRADE_COMPARE(sceneMappingTypeSize(SceneMappingType::UnsignedInt), 4);
+    CORRADE_COMPARE(sceneMappingTypeAlignment(SceneMappingType::UnsignedInt), 4);
+    CORRADE_COMPARE(sceneMappingTypeSize(SceneMappingType::UnsignedLong), 8);
+    CORRADE_COMPARE(sceneMappingTypeAlignment(SceneMappingType::UnsignedLong), 8);
 }
 
-void SceneDataTest::objectTypeSizeAlignmentInvalid() {
+void SceneDataTest::mappingTypeSizeAlignmentInvalid() {
     #ifdef CORRADE_NO_ASSERT
     CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
     #endif
@@ -522,22 +522,22 @@ void SceneDataTest::objectTypeSizeAlignmentInvalid() {
     std::ostringstream out;
     Error redirectError{&out};
 
-    sceneObjectTypeSize(SceneObjectType{});
-    sceneObjectTypeAlignment(SceneObjectType{});
-    sceneObjectTypeSize(SceneObjectType(0x73));
-    sceneObjectTypeAlignment(SceneObjectType(0x73));
+    sceneMappingTypeSize(SceneMappingType{});
+    sceneMappingTypeAlignment(SceneMappingType{});
+    sceneMappingTypeSize(SceneMappingType(0x73));
+    sceneMappingTypeAlignment(SceneMappingType(0x73));
 
     CORRADE_COMPARE(out.str(),
-        "Trade::sceneObjectTypeSize(): invalid type Trade::SceneObjectType(0x0)\n"
-        "Trade::sceneObjectTypeAlignment(): invalid type Trade::SceneObjectType(0x0)\n"
-        "Trade::sceneObjectTypeSize(): invalid type Trade::SceneObjectType(0x73)\n"
-        "Trade::sceneObjectTypeAlignment(): invalid type Trade::SceneObjectType(0x73)\n");
+        "Trade::sceneMappingTypeSize(): invalid type Trade::SceneMappingType(0x0)\n"
+        "Trade::sceneMappingTypeAlignment(): invalid type Trade::SceneMappingType(0x0)\n"
+        "Trade::sceneMappingTypeSize(): invalid type Trade::SceneMappingType(0x73)\n"
+        "Trade::sceneMappingTypeAlignment(): invalid type Trade::SceneMappingType(0x73)\n");
 }
 
-void SceneDataTest::debugObjectType() {
+void SceneDataTest::debugMappingType() {
     std::ostringstream out;
-    Debug{&out} << SceneObjectType::UnsignedLong << SceneObjectType(0x73);
-    CORRADE_COMPARE(out.str(), "Trade::SceneObjectType::UnsignedLong Trade::SceneObjectType(0x73)\n");
+    Debug{&out} << SceneMappingType::UnsignedLong << SceneMappingType(0x73);
+    CORRADE_COMPARE(out.str(), "Trade::SceneMappingType::UnsignedLong Trade::SceneMappingType(0x73)\n");
 }
 
 void SceneDataTest::customFieldName() {
@@ -645,29 +645,29 @@ void SceneDataTest::debugFieldType() {
     CORRADE_COMPARE(out.str(), "Trade::SceneFieldType::Matrix3x4h Trade::SceneFieldType(0xdead)\n");
 }
 
-constexpr Complexd Rotations2D[3] {
-    Complexd{Constantsd::sqrtHalf(), Constantsd::sqrtHalf()}, /* 45° */
-    Complexd{1.0, 0.0}, /* 0° */
-    Complexd{0.0, 1.0}, /* 90° */
-};
-const UnsignedShort RotationObjects2D[3] {
+const UnsignedShort RotationMapping2D[3] {
     17,
     35,
     98
 };
+constexpr Complexd RotationField2D[3] {
+    Complexd{Constantsd::sqrtHalf(), Constantsd::sqrtHalf()}, /* 45° */
+    Complexd{1.0, 0.0}, /* 0° */
+    Complexd{0.0, 1.0}, /* 90° */
+};
 
 void SceneDataTest::constructField() {
-    const UnsignedShort rotationObjectData[3]{};
+    const UnsignedShort rotationMappingData[3]{};
     const Complexd rotationFieldData[3];
 
-    SceneFieldData rotations{SceneField::Rotation, Containers::arrayView(rotationObjectData), Containers::arrayView(rotationFieldData)};
+    SceneFieldData rotations{SceneField::Rotation, Containers::arrayView(rotationMappingData), Containers::arrayView(rotationFieldData)};
     CORRADE_VERIFY(!rotations.isOffsetOnly());
     CORRADE_COMPARE(rotations.name(), SceneField::Rotation);
     CORRADE_COMPARE(rotations.size(), 3);
-    CORRADE_COMPARE(rotations.objectType(), SceneObjectType::UnsignedShort);
-    CORRADE_COMPARE(rotations.objectData().size(), 3);
-    CORRADE_COMPARE(rotations.objectData().stride(), sizeof(UnsignedShort));
-    CORRADE_VERIFY(rotations.objectData().data() == rotationObjectData);
+    CORRADE_COMPARE(rotations.mappingType(), SceneMappingType::UnsignedShort);
+    CORRADE_COMPARE(rotations.mappingData().size(), 3);
+    CORRADE_COMPARE(rotations.mappingData().stride(), sizeof(UnsignedShort));
+    CORRADE_VERIFY(rotations.mappingData().data() == rotationMappingData);
     CORRADE_COMPARE(rotations.fieldType(), SceneFieldType::Complexd);
     CORRADE_COMPARE(rotations.fieldArraySize(), 0);
     CORRADE_COMPARE(rotations.fieldData().size(), 3);
@@ -680,30 +680,30 @@ void SceneDataTest::constructField() {
     CORRADE_COMPARE(rotations.fieldData(someArray).size(), 3);
     CORRADE_COMPARE(rotations.fieldData(someArray).stride(), sizeof(Complexd));
     CORRADE_VERIFY(rotations.fieldData(someArray).data() == rotationFieldData);
-    CORRADE_COMPARE(rotations.objectData(someArray).size(), 3);
-    CORRADE_COMPARE(rotations.objectData(someArray).stride(), sizeof(UnsignedShort));
-    CORRADE_VERIFY(rotations.objectData(someArray).data() == rotationObjectData);
+    CORRADE_COMPARE(rotations.mappingData(someArray).size(), 3);
+    CORRADE_COMPARE(rotations.mappingData(someArray).stride(), sizeof(UnsignedShort));
+    CORRADE_VERIFY(rotations.mappingData(someArray).data() == rotationMappingData);
 
     #ifndef CORRADE_MSVC2015_COMPATIBILITY /* Won't bother anymore */
-    constexpr SceneFieldData crotations{SceneField::Rotation, Containers::arrayView(RotationObjects2D), Containers::arrayView(Rotations2D)};
+    constexpr SceneFieldData crotations{SceneField::Rotation, Containers::arrayView(RotationMapping2D), Containers::arrayView(RotationField2D)};
     constexpr bool isOffsetOnly = crotations.isOffsetOnly();
     constexpr SceneField name = crotations.name();
-    constexpr SceneObjectType objectType = crotations.objectType();
-    constexpr Containers::StridedArrayView1D<const void> objectData = crotations.objectData();
+    constexpr SceneMappingType mappingType = crotations.mappingType();
+    constexpr Containers::StridedArrayView1D<const void> mappingData = crotations.mappingData();
     constexpr SceneFieldType fieldType = crotations.fieldType();
     constexpr UnsignedShort fieldArraySize = crotations.fieldArraySize();
     constexpr Containers::StridedArrayView1D<const void> fieldData = crotations.fieldData();
     CORRADE_VERIFY(!isOffsetOnly);
     CORRADE_COMPARE(name, SceneField::Rotation);
-    CORRADE_COMPARE(objectType, SceneObjectType::UnsignedShort);
-    CORRADE_COMPARE(objectData.size(), 3);
-    CORRADE_COMPARE(objectData.stride(), sizeof(UnsignedShort));
-    CORRADE_COMPARE(objectData.data(), RotationObjects2D);
+    CORRADE_COMPARE(mappingType, SceneMappingType::UnsignedShort);
+    CORRADE_COMPARE(mappingData.size(), 3);
+    CORRADE_COMPARE(mappingData.stride(), sizeof(UnsignedShort));
+    CORRADE_COMPARE(mappingData.data(), RotationMapping2D);
     CORRADE_COMPARE(fieldType, SceneFieldType::Complexd);
     CORRADE_COMPARE(fieldArraySize, 0);
     CORRADE_COMPARE(fieldData.size(), 3);
     CORRADE_COMPARE(fieldData.stride(), sizeof(Complexd));
-    CORRADE_COMPARE(fieldData.data(), Rotations2D);
+    CORRADE_COMPARE(fieldData.data(), RotationField2D);
     #endif
 }
 
@@ -711,42 +711,42 @@ void SceneDataTest::constructFieldDefault() {
     SceneFieldData data;
     CORRADE_COMPARE(data.name(), SceneField{});
     CORRADE_COMPARE(data.fieldType(), SceneFieldType{});
-    CORRADE_COMPARE(data.objectType(), SceneObjectType{});
+    CORRADE_COMPARE(data.mappingType(), SceneMappingType{});
 
     constexpr SceneFieldData cdata;
     CORRADE_COMPARE(cdata.name(), SceneField{});
     CORRADE_COMPARE(cdata.fieldType(), SceneFieldType{});
-    CORRADE_COMPARE(cdata.objectType(), SceneObjectType{});
+    CORRADE_COMPARE(cdata.mappingType(), SceneMappingType{});
 }
 
 void SceneDataTest::constructFieldCustom() {
     /* Verifying it doesn't hit any assertion about disallowed type for given
        attribute */
 
-    const UnsignedByte rangeObjectData[3]{};
+    const UnsignedByte rangeMappingData[3]{};
     const Range2Dh rangeFieldData[3];
-    SceneFieldData ranges{sceneFieldCustom(13), Containers::arrayView(rangeObjectData), Containers::arrayView(rangeFieldData)};
+    SceneFieldData ranges{sceneFieldCustom(13), Containers::arrayView(rangeMappingData), Containers::arrayView(rangeFieldData)};
     CORRADE_COMPARE(ranges.name(), sceneFieldCustom(13));
-    CORRADE_COMPARE(ranges.objectType(), SceneObjectType::UnsignedByte);
-    CORRADE_VERIFY(ranges.objectData().data() == rangeObjectData);
+    CORRADE_COMPARE(ranges.mappingType(), SceneMappingType::UnsignedByte);
+    CORRADE_VERIFY(ranges.mappingData().data() == rangeMappingData);
     CORRADE_COMPARE(ranges.fieldType(), SceneFieldType::Range2Dh);
     CORRADE_VERIFY(ranges.fieldData().data() == rangeFieldData);
 }
 
 void SceneDataTest::constructField2D() {
-    char rotationObjectData[6*sizeof(UnsignedShort)];
+    char rotationMappingData[6*sizeof(UnsignedShort)];
     char rotationFieldData[6*sizeof(Complexd)];
-    auto rotationObjectView = Containers::StridedArrayView2D<char>{rotationObjectData, {6, sizeof(UnsignedShort)}}.every(2);
+    auto rotationMappingView = Containers::StridedArrayView2D<char>{rotationMappingData, {6, sizeof(UnsignedShort)}}.every(2);
     auto rotationFieldView = Containers::StridedArrayView2D<char>{rotationFieldData, {6, sizeof(Complexd)}}.every(2);
 
-    SceneFieldData rotations{SceneField::Rotation, rotationObjectView, SceneFieldType::Complexd, rotationFieldView};
+    SceneFieldData rotations{SceneField::Rotation, rotationMappingView, SceneFieldType::Complexd, rotationFieldView};
     CORRADE_VERIFY(!rotations.isOffsetOnly());
     CORRADE_COMPARE(rotations.name(), SceneField::Rotation);
     CORRADE_COMPARE(rotations.size(), 3);
-    CORRADE_COMPARE(rotations.objectType(), SceneObjectType::UnsignedShort);
-    CORRADE_COMPARE(rotations.objectData().size(), 3);
-    CORRADE_COMPARE(rotations.objectData().stride(), 2*sizeof(UnsignedShort));
-    CORRADE_COMPARE(rotations.objectData().data(), rotationObjectView.data());
+    CORRADE_COMPARE(rotations.mappingType(), SceneMappingType::UnsignedShort);
+    CORRADE_COMPARE(rotations.mappingData().size(), 3);
+    CORRADE_COMPARE(rotations.mappingData().stride(), 2*sizeof(UnsignedShort));
+    CORRADE_COMPARE(rotations.mappingData().data(), rotationMappingView.data());
     CORRADE_COMPARE(rotations.fieldType(), SceneFieldType::Complexd);
     CORRADE_COMPARE(rotations.fieldArraySize(), 0);
     CORRADE_COMPARE(rotations.fieldData().size(), 3);
@@ -755,16 +755,16 @@ void SceneDataTest::constructField2D() {
 }
 
 void SceneDataTest::constructFieldTypeErased() {
-    const UnsignedLong scalingObjectData[3]{};
+    const UnsignedLong scalingMappingData[3]{};
     const Vector3 scalingFieldData[3];
-    SceneFieldData scalings{SceneField::Scaling, SceneObjectType::UnsignedLong, Containers::arrayCast<const char>(Containers::stridedArrayView(scalingObjectData)), SceneFieldType::Vector3, Containers::arrayCast<const char>(Containers::stridedArrayView(scalingFieldData))};
+    SceneFieldData scalings{SceneField::Scaling, SceneMappingType::UnsignedLong, Containers::arrayCast<const char>(Containers::stridedArrayView(scalingMappingData)), SceneFieldType::Vector3, Containers::arrayCast<const char>(Containers::stridedArrayView(scalingFieldData))};
     CORRADE_VERIFY(!scalings.isOffsetOnly());
     CORRADE_COMPARE(scalings.name(), SceneField::Scaling);
     CORRADE_COMPARE(scalings.size(), 3);
-    CORRADE_COMPARE(scalings.objectType(), SceneObjectType::UnsignedLong);
-    CORRADE_COMPARE(scalings.objectData().size(), 3);
-    CORRADE_COMPARE(scalings.objectData().stride(), sizeof(UnsignedLong));
-    CORRADE_COMPARE(scalings.objectData().data(), scalingObjectData);
+    CORRADE_COMPARE(scalings.mappingType(), SceneMappingType::UnsignedLong);
+    CORRADE_COMPARE(scalings.mappingData().size(), 3);
+    CORRADE_COMPARE(scalings.mappingData().stride(), sizeof(UnsignedLong));
+    CORRADE_COMPARE(scalings.mappingData().data(), scalingMappingData);
     CORRADE_COMPARE(scalings.fieldType(), SceneFieldType::Vector3);
     CORRADE_COMPARE(scalings.fieldArraySize(), 0);
     CORRADE_COMPARE(scalings.fieldData().size(), 3);
@@ -789,14 +789,14 @@ void SceneDataTest::constructFieldOffsetOnly() {
         {0, 15, {67.0f, -1.1f}}
     };
 
-    SceneFieldData a{SceneField::Translation, 2, SceneObjectType::UnsignedShort, offsetof(Data, object), sizeof(Data), SceneFieldType::Vector2, offsetof(Data, translation), sizeof(Data)};
+    SceneFieldData a{SceneField::Translation, 2, SceneMappingType::UnsignedShort, offsetof(Data, object), sizeof(Data), SceneFieldType::Vector2, offsetof(Data, translation), sizeof(Data)};
     CORRADE_VERIFY(a.isOffsetOnly());
     CORRADE_COMPARE(a.name(), SceneField::Translation);
     CORRADE_COMPARE(a.size(), 2);
-    CORRADE_COMPARE(a.objectType(), SceneObjectType::UnsignedShort);
-    CORRADE_COMPARE(a.objectData(data).size(), 2);
-    CORRADE_COMPARE(a.objectData(data).stride(), sizeof(Data));
-    CORRADE_COMPARE_AS(Containers::arrayCast<const UnsignedShort>(a.objectData(data)),
+    CORRADE_COMPARE(a.mappingType(), SceneMappingType::UnsignedShort);
+    CORRADE_COMPARE(a.mappingData(data).size(), 2);
+    CORRADE_COMPARE(a.mappingData(data).stride(), sizeof(Data));
+    CORRADE_COMPARE_AS(Containers::arrayCast<const UnsignedShort>(a.mappingData(data)),
         Containers::arrayView<UnsignedShort>({2, 15}),
         TestSuite::Compare::Container);
     CORRADE_COMPARE(a.fieldType(), SceneFieldType::Vector2);
@@ -808,34 +808,34 @@ void SceneDataTest::constructFieldOffsetOnly() {
         TestSuite::Compare::Container);
 }
 
-constexpr UnsignedByte ArrayOffsetObjectData[3]{};
+constexpr UnsignedByte ArrayOffsetMappingData[3]{};
 constexpr Int ArrayOffsetFieldData[3*4]{};
 
 void SceneDataTest::constructFieldArray() {
-    UnsignedByte offsetObjectData[3];
+    UnsignedByte offsetMappingData[3];
     Int offsetFieldData[3*4];
-    SceneFieldData data{sceneFieldCustom(34), Containers::arrayView(offsetObjectData), Containers::StridedArrayView2D<Int>{offsetFieldData, {3, 4}}};
+    SceneFieldData data{sceneFieldCustom(34), Containers::arrayView(offsetMappingData), Containers::StridedArrayView2D<Int>{offsetFieldData, {3, 4}}};
     CORRADE_VERIFY(!data.isOffsetOnly());
     CORRADE_COMPARE(data.name(), sceneFieldCustom(34));
     CORRADE_COMPARE(data.size(), 3);
-    CORRADE_COMPARE(data.objectType(), SceneObjectType::UnsignedByte);
-    CORRADE_COMPARE(data.objectData().size(), 3);
-    CORRADE_COMPARE(data.objectData().stride(), sizeof(UnsignedByte));
-    CORRADE_VERIFY(data.objectData().data() == offsetObjectData);
+    CORRADE_COMPARE(data.mappingType(), SceneMappingType::UnsignedByte);
+    CORRADE_COMPARE(data.mappingData().size(), 3);
+    CORRADE_COMPARE(data.mappingData().stride(), sizeof(UnsignedByte));
+    CORRADE_VERIFY(data.mappingData().data() == offsetMappingData);
     CORRADE_COMPARE(data.fieldType(), SceneFieldType::Int);
     CORRADE_COMPARE(data.fieldArraySize(), 4);
     CORRADE_COMPARE(data.fieldData().size(), 3);
     CORRADE_COMPARE(data.fieldData().stride(), 4*sizeof(Int));
     CORRADE_VERIFY(data.fieldData().data() == offsetFieldData);
 
-    constexpr SceneFieldData cdata{sceneFieldCustom(34), Containers::arrayView(ArrayOffsetObjectData), Containers::StridedArrayView2D<const Int>{ArrayOffsetFieldData, {3, 4}}};
+    constexpr SceneFieldData cdata{sceneFieldCustom(34), Containers::arrayView(ArrayOffsetMappingData), Containers::StridedArrayView2D<const Int>{ArrayOffsetFieldData, {3, 4}}};
     CORRADE_VERIFY(!cdata.isOffsetOnly());
     CORRADE_COMPARE(cdata.name(), sceneFieldCustom(34));
     CORRADE_COMPARE(cdata.size(), 3);
-    CORRADE_COMPARE(cdata.objectType(), SceneObjectType::UnsignedByte);
-    CORRADE_COMPARE(cdata.objectData().size(), 3);
-    CORRADE_COMPARE(cdata.objectData().stride(), sizeof(UnsignedByte));
-    CORRADE_VERIFY(cdata.objectData().data() == ArrayOffsetObjectData);
+    CORRADE_COMPARE(cdata.mappingType(), SceneMappingType::UnsignedByte);
+    CORRADE_COMPARE(cdata.mappingData().size(), 3);
+    CORRADE_COMPARE(cdata.mappingData().stride(), sizeof(UnsignedByte));
+    CORRADE_VERIFY(cdata.mappingData().data() == ArrayOffsetMappingData);
     CORRADE_COMPARE(cdata.fieldType(), SceneFieldType::Int);
     CORRADE_COMPARE(cdata.fieldArraySize(), 4);
     CORRADE_COMPARE(cdata.fieldData().size(), 3);
@@ -844,16 +844,16 @@ void SceneDataTest::constructFieldArray() {
 }
 
 void SceneDataTest::constructFieldArray2D() {
-    char offsetObjectData[3*sizeof(UnsignedByte)];
+    char offsetMappingData[3*sizeof(UnsignedByte)];
     char offsetFieldData[3*4*sizeof(Int)];
-    SceneFieldData data{sceneFieldCustom(34), Containers::StridedArrayView2D<char>{offsetObjectData, {3, sizeof(UnsignedByte)}}, SceneFieldType::Int, Containers::StridedArrayView2D<char>{offsetFieldData, {3, 4*sizeof(Int)}}, 4};
+    SceneFieldData data{sceneFieldCustom(34), Containers::StridedArrayView2D<char>{offsetMappingData, {3, sizeof(UnsignedByte)}}, SceneFieldType::Int, Containers::StridedArrayView2D<char>{offsetFieldData, {3, 4*sizeof(Int)}}, 4};
     CORRADE_VERIFY(!data.isOffsetOnly());
     CORRADE_COMPARE(data.name(), sceneFieldCustom(34));
     CORRADE_COMPARE(data.size(), 3);
-    CORRADE_COMPARE(data.objectType(), SceneObjectType::UnsignedByte);
-    CORRADE_COMPARE(data.objectData().size(), 3);
-    CORRADE_COMPARE(data.objectData().stride(), sizeof(UnsignedByte));
-    CORRADE_VERIFY(data.objectData().data() == offsetObjectData);
+    CORRADE_COMPARE(data.mappingType(), SceneMappingType::UnsignedByte);
+    CORRADE_COMPARE(data.mappingData().size(), 3);
+    CORRADE_COMPARE(data.mappingData().stride(), sizeof(UnsignedByte));
+    CORRADE_VERIFY(data.mappingData().data() == offsetMappingData);
     CORRADE_COMPARE(data.fieldType(), SceneFieldType::Int);
     CORRADE_COMPARE(data.fieldArraySize(), 4);
     CORRADE_COMPARE(data.fieldData().size(), 3);
@@ -862,22 +862,22 @@ void SceneDataTest::constructFieldArray2D() {
 }
 
 void SceneDataTest::constructFieldArrayTypeErased() {
-    Int offsetData[3*4];
-    Containers::StridedArrayView1D<Int> offset{offsetData, 3, 4*sizeof(Int)};
-    UnsignedByte offsetObjectData[3];
-    SceneFieldData data{sceneFieldCustom(34), SceneObjectType::UnsignedByte, Containers::arrayCast<const char>(Containers::stridedArrayView(offsetObjectData)), SceneFieldType::Int, Containers::arrayCast<const char>(offset), 4};
+    UnsignedByte offsetMappingData[3];
+    Int offsetFieldData[3*4];
+    Containers::StridedArrayView1D<Int> offset{offsetFieldData, 3, 4*sizeof(Int)};
+    SceneFieldData data{sceneFieldCustom(34), SceneMappingType::UnsignedByte, Containers::arrayCast<const char>(Containers::stridedArrayView(offsetMappingData)), SceneFieldType::Int, Containers::arrayCast<const char>(offset), 4};
     CORRADE_VERIFY(!data.isOffsetOnly());
     CORRADE_COMPARE(data.name(), sceneFieldCustom(34));
     CORRADE_COMPARE(data.size(), 3);
     CORRADE_COMPARE(data.fieldType(), SceneFieldType::Int);
-    CORRADE_COMPARE(data.objectType(), SceneObjectType::UnsignedByte);
-    CORRADE_COMPARE(data.objectData().size(), 3);
-    CORRADE_COMPARE(data.objectData().stride(), sizeof(UnsignedByte));
-    CORRADE_VERIFY(data.objectData().data() == offsetObjectData);
+    CORRADE_COMPARE(data.mappingType(), SceneMappingType::UnsignedByte);
+    CORRADE_COMPARE(data.mappingData().size(), 3);
+    CORRADE_COMPARE(data.mappingData().stride(), sizeof(UnsignedByte));
+    CORRADE_VERIFY(data.mappingData().data() == offsetMappingData);
     CORRADE_COMPARE(data.fieldArraySize(), 4);
     CORRADE_COMPARE(data.fieldData().size(), 3);
     CORRADE_COMPARE(data.fieldData().stride(), 4*sizeof(Int));
-    CORRADE_VERIFY(data.fieldData().data() == offsetData);
+    CORRADE_VERIFY(data.fieldData().data() == offsetFieldData);
 }
 
 void SceneDataTest::constructFieldArrayOffsetOnly() {
@@ -887,11 +887,11 @@ void SceneDataTest::constructFieldArrayOffsetOnly() {
         Int offset[4];
     };
 
-    SceneFieldData data{sceneFieldCustom(34), 3, SceneObjectType::UnsignedByte, offsetof(Data, object), sizeof(Data), SceneFieldType::Int, offsetof(Data, offset), sizeof(Data), 4};
+    SceneFieldData data{sceneFieldCustom(34), 3, SceneMappingType::UnsignedByte, offsetof(Data, object), sizeof(Data), SceneFieldType::Int, offsetof(Data, offset), sizeof(Data), 4};
     CORRADE_VERIFY(data.isOffsetOnly());
     CORRADE_COMPARE(data.name(), sceneFieldCustom(34));
     CORRADE_COMPARE(data.size(), 3);
-    CORRADE_COMPARE(data.objectType(), SceneObjectType::UnsignedByte);
+    CORRADE_COMPARE(data.mappingType(), SceneMappingType::UnsignedByte);
     CORRADE_COMPARE(data.fieldType(), SceneFieldType::Int);
     CORRADE_COMPARE(data.fieldArraySize(), 4);
 
@@ -899,15 +899,15 @@ void SceneDataTest::constructFieldArrayOffsetOnly() {
     CORRADE_COMPARE(data.fieldData(actual).size(), 3);
     CORRADE_COMPARE(data.fieldData(actual).stride(), sizeof(Data));
     CORRADE_VERIFY(data.fieldData(actual).data() == &actual[0].offset);
-    CORRADE_COMPARE(data.objectData(actual).size(), 3);
-    CORRADE_COMPARE(data.objectData(actual).stride(), sizeof(Data));
-    CORRADE_VERIFY(data.objectData(actual).data() == &actual[0].object);
+    CORRADE_COMPARE(data.mappingData(actual).size(), 3);
+    CORRADE_COMPARE(data.mappingData(actual).stride(), sizeof(Data));
+    CORRADE_VERIFY(data.mappingData(actual).data() == &actual[0].object);
 
-    constexpr SceneFieldData cdata{sceneFieldCustom(34), 3, SceneObjectType::UnsignedByte, offsetof(Data, object), sizeof(Data), SceneFieldType::Int, offsetof(Data, offset), sizeof(Data), 4};
+    constexpr SceneFieldData cdata{sceneFieldCustom(34), 3, SceneMappingType::UnsignedByte, offsetof(Data, object), sizeof(Data), SceneFieldType::Int, offsetof(Data, offset), sizeof(Data), 4};
     CORRADE_VERIFY(cdata.isOffsetOnly());
     CORRADE_COMPARE(cdata.name(), sceneFieldCustom(34));
     CORRADE_COMPARE(cdata.size(), 3);
-    CORRADE_COMPARE(cdata.objectType(), SceneObjectType::UnsignedByte);
+    CORRADE_COMPARE(cdata.mappingType(), SceneMappingType::UnsignedByte);
     CORRADE_COMPARE(cdata.fieldType(), SceneFieldType::Int);
     CORRADE_COMPARE(cdata.fieldArraySize(), 4);
 }
@@ -917,13 +917,13 @@ void SceneDataTest::constructFieldInconsistentViewSize() {
     CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
     #endif
 
-    const UnsignedShort rotationObjectData[3]{};
+    const UnsignedShort rotationMappingData[3]{};
     const Complexd rotationFieldData[2];
 
     std::ostringstream out;
     Error redirectError{&out};
-    SceneFieldData{SceneField::Rotation, Containers::arrayView(rotationObjectData), Containers::arrayView(rotationFieldData)};
-    CORRADE_COMPARE(out.str(), "Trade::SceneFieldData: expected object and field view to have the same size but got 3 and 2\n");
+    SceneFieldData{SceneField::Rotation, Containers::arrayView(rotationMappingData), Containers::arrayView(rotationFieldData)};
+    CORRADE_COMPARE(out.str(), "Trade::SceneFieldData: expected mapping and field view to have the same size but got 3 and 2\n");
 }
 
 void SceneDataTest::constructFieldWrongType() {
@@ -931,19 +931,19 @@ void SceneDataTest::constructFieldWrongType() {
     CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
     #endif
 
-    const UnsignedShort rotationObjectData[3]{};
+    const UnsignedShort rotationMappingData[3]{};
     const Quaternion rotationFieldData[3];
 
     std::ostringstream out;
     Error redirectError{&out};
-    SceneFieldData{SceneField::Transformation, Containers::arrayView(rotationObjectData), Containers::arrayView(rotationFieldData)};
-    SceneFieldData{SceneField::Transformation, 3, SceneObjectType::UnsignedShort, 0, sizeof(UnsignedShort), SceneFieldType::Quaternion, 0, sizeof(Quaternion)};
+    SceneFieldData{SceneField::Transformation, Containers::arrayView(rotationMappingData), Containers::arrayView(rotationFieldData)};
+    SceneFieldData{SceneField::Transformation, 3, SceneMappingType::UnsignedShort, 0, sizeof(UnsignedShort), SceneFieldType::Quaternion, 0, sizeof(Quaternion)};
     CORRADE_COMPARE(out.str(),
         "Trade::SceneFieldData: Trade::SceneFieldType::Quaternion is not a valid type for Trade::SceneField::Transformation\n"
         "Trade::SceneFieldData: Trade::SceneFieldType::Quaternion is not a valid type for Trade::SceneField::Transformation\n");
 }
 
-void SceneDataTest::constructFieldTooLargeObjectStride() {
+void SceneDataTest::constructFieldTooLargeMappingStride() {
     #ifdef CORRADE_NO_ASSERT
     CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
     #endif
@@ -952,22 +952,22 @@ void SceneDataTest::constructFieldTooLargeObjectStride() {
     char toomuch[2*(32768 + sizeof(UnsignedInt))];
 
     /* These should be fine */
-    SceneFieldData{SceneField::Mesh, SceneObjectType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32767}, SceneFieldType::UnsignedInt, enough};
-    SceneFieldData{SceneField::Mesh, SceneObjectType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32768}.flipped<0>(), SceneFieldType::UnsignedInt, enough};
-    SceneFieldData{SceneField::Mesh, 2, SceneObjectType::UnsignedInt, 0, 32767, SceneFieldType::UnsignedInt, 0, 4};
-    SceneFieldData{SceneField::Mesh, 2, SceneObjectType::UnsignedInt, 65536, -32768, SceneFieldType::UnsignedInt, 0, 4};
+    SceneFieldData{SceneField::Mesh, SceneMappingType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32767}, SceneFieldType::UnsignedInt, enough};
+    SceneFieldData{SceneField::Mesh, SceneMappingType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32768}.flipped<0>(), SceneFieldType::UnsignedInt, enough};
+    SceneFieldData{SceneField::Mesh, 2, SceneMappingType::UnsignedInt, 0, 32767, SceneFieldType::UnsignedInt, 0, 4};
+    SceneFieldData{SceneField::Mesh, 2, SceneMappingType::UnsignedInt, 65536, -32768, SceneFieldType::UnsignedInt, 0, 4};
 
     std::ostringstream out;
     Error redirectError{&out};
-    SceneFieldData{SceneField::Mesh, SceneObjectType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32768}, SceneFieldType::UnsignedInt, enough};
-    SceneFieldData{SceneField::Mesh, SceneObjectType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32769}.flipped<0>(), SceneFieldType::UnsignedInt, enough};
-    SceneFieldData{SceneField::Mesh, 2, SceneObjectType::UnsignedInt, 0, 32768, SceneFieldType::UnsignedInt, 0, 4};
-    SceneFieldData{SceneField::Mesh, 2, SceneObjectType::UnsignedInt, 65538, -32769, SceneFieldType::UnsignedInt, 0, 4};
+    SceneFieldData{SceneField::Mesh, SceneMappingType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32768}, SceneFieldType::UnsignedInt, enough};
+    SceneFieldData{SceneField::Mesh, SceneMappingType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32769}.flipped<0>(), SceneFieldType::UnsignedInt, enough};
+    SceneFieldData{SceneField::Mesh, 2, SceneMappingType::UnsignedInt, 0, 32768, SceneFieldType::UnsignedInt, 0, 4};
+    SceneFieldData{SceneField::Mesh, 2, SceneMappingType::UnsignedInt, 65538, -32769, SceneFieldType::UnsignedInt, 0, 4};
     CORRADE_COMPARE(out.str(),
-        "Trade::SceneFieldData: expected object view stride to fit into 16 bits, but got 32768\n"
-        "Trade::SceneFieldData: expected object view stride to fit into 16 bits, but got -32769\n"
-        "Trade::SceneFieldData: expected object view stride to fit into 16 bits, but got 32768\n"
-        "Trade::SceneFieldData: expected object view stride to fit into 16 bits, but got -32769\n");
+        "Trade::SceneFieldData: expected mapping view stride to fit into 16 bits, but got 32768\n"
+        "Trade::SceneFieldData: expected mapping view stride to fit into 16 bits, but got -32769\n"
+        "Trade::SceneFieldData: expected mapping view stride to fit into 16 bits, but got 32768\n"
+        "Trade::SceneFieldData: expected mapping view stride to fit into 16 bits, but got -32769\n");
 }
 
 void SceneDataTest::constructFieldTooLargeFieldStride() {
@@ -979,17 +979,17 @@ void SceneDataTest::constructFieldTooLargeFieldStride() {
     char toomuch[2*(32768 + sizeof(UnsignedInt))];
 
     /* These should be fine */
-    SceneFieldData{SceneField::Mesh, SceneObjectType::UnsignedInt, enough, SceneFieldType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32767}};
-    SceneFieldData{SceneField::Mesh, SceneObjectType::UnsignedInt, enough, SceneFieldType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32768}.flipped<0>()};
-    SceneFieldData{SceneField::Mesh, 2, SceneObjectType::UnsignedInt, 0, 4, SceneFieldType::UnsignedInt, 0, 32767};
-    SceneFieldData{SceneField::Mesh, 2, SceneObjectType::UnsignedInt, 0, 4, SceneFieldType::UnsignedInt, 65536, -32768};
+    SceneFieldData{SceneField::Mesh, SceneMappingType::UnsignedInt, enough, SceneFieldType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32767}};
+    SceneFieldData{SceneField::Mesh, SceneMappingType::UnsignedInt, enough, SceneFieldType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32768}.flipped<0>()};
+    SceneFieldData{SceneField::Mesh, 2, SceneMappingType::UnsignedInt, 0, 4, SceneFieldType::UnsignedInt, 0, 32767};
+    SceneFieldData{SceneField::Mesh, 2, SceneMappingType::UnsignedInt, 0, 4, SceneFieldType::UnsignedInt, 65536, -32768};
 
     std::ostringstream out;
     Error redirectError{&out};
-    SceneFieldData{SceneField::Mesh, SceneObjectType::UnsignedInt, enough, SceneFieldType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32768}};
-    SceneFieldData{SceneField::Mesh, SceneObjectType::UnsignedInt, enough, SceneFieldType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32769}.flipped<0>()};
-    SceneFieldData{SceneField::Mesh, 2, SceneObjectType::UnsignedInt, 0, 4, SceneFieldType::UnsignedInt, 0, 32768};
-    SceneFieldData{SceneField::Mesh, 2, SceneObjectType::UnsignedInt, 0, 4, SceneFieldType::UnsignedInt, 65538, -32769};
+    SceneFieldData{SceneField::Mesh, SceneMappingType::UnsignedInt, enough, SceneFieldType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32768}};
+    SceneFieldData{SceneField::Mesh, SceneMappingType::UnsignedInt, enough, SceneFieldType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32769}.flipped<0>()};
+    SceneFieldData{SceneField::Mesh, 2, SceneMappingType::UnsignedInt, 0, 4, SceneFieldType::UnsignedInt, 0, 32768};
+    SceneFieldData{SceneField::Mesh, 2, SceneMappingType::UnsignedInt, 0, 4, SceneFieldType::UnsignedInt, 65538, -32769};
     CORRADE_COMPARE(out.str(),
         "Trade::SceneFieldData: expected field view stride to fit into 16 bits, but got 32768\n"
         "Trade::SceneFieldData: expected field view stride to fit into 16 bits, but got -32769\n"
@@ -1002,22 +1002,22 @@ void SceneDataTest::constructFieldWrongDataAccess() {
     CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
     #endif
 
-    const UnsignedShort rotationObjectData[3]{};
+    const UnsignedShort rotationMappingData[3]{};
     const Quaternion rotationFieldData[3];
-    SceneFieldData a{SceneField::Rotation, Containers::arrayView(rotationObjectData), Containers::arrayView(rotationFieldData)};
-    SceneFieldData b{SceneField::Rotation, 3, SceneObjectType::UnsignedShort, 0, sizeof(UnsignedShort), SceneFieldType::Quaternion, 0, sizeof(Quaternion)};
+    SceneFieldData a{SceneField::Rotation, Containers::arrayView(rotationMappingData), Containers::arrayView(rotationFieldData)};
+    SceneFieldData b{SceneField::Rotation, 3, SceneMappingType::UnsignedShort, 0, sizeof(UnsignedShort), SceneFieldType::Quaternion, 0, sizeof(Quaternion)};
     CORRADE_VERIFY(!a.isOffsetOnly());
     CORRADE_VERIFY(b.isOffsetOnly());
 
-    a.objectData(rotationObjectData); /* This is fine, no asserts */
+    a.mappingData(rotationMappingData); /* This is fine, no asserts */
     a.fieldData(rotationFieldData);
 
     std::ostringstream out;
     Error redirectError{&out};
-    b.objectData();
+    b.mappingData();
     b.fieldData();
     CORRADE_COMPARE(out.str(),
-        "Trade::SceneFieldData::objectData(): the field is offset-only, supply a data array\n"
+        "Trade::SceneFieldData::mappingData(): the field is offset-only, supply a data array\n"
         "Trade::SceneFieldData::fieldData(): the field is offset-only, supply a data array\n");
 }
 
@@ -1026,21 +1026,21 @@ void SceneDataTest::constructField2DWrongSize() {
     CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
     #endif
 
+    char rotationMappingData[5*sizeof(UnsignedInt)];
     char rotationFieldData[5*sizeof(Complex)];
-    char rotationObjectData[5*sizeof(UnsignedInt)];
 
     std::ostringstream out;
     Error redirectError{&out};
     SceneFieldData{SceneField::Rotation,
-        Containers::StridedArrayView2D<char>{rotationObjectData, {4, 5}}.every(2),
+        Containers::StridedArrayView2D<char>{rotationMappingData, {4, 5}}.every(2),
         SceneFieldType::Complex,
         Containers::StridedArrayView2D<char>{rotationFieldData, {4, sizeof(Complex)}}.every(2)};
     SceneFieldData{SceneField::Translation,
-        Containers::StridedArrayView2D<char>{rotationObjectData, {4, sizeof(UnsignedInt)}}.every(2),
+        Containers::StridedArrayView2D<char>{rotationMappingData, {4, sizeof(UnsignedInt)}}.every(2),
         SceneFieldType::Vector3,
         Containers::StridedArrayView2D<char>{rotationFieldData, {4, sizeof(Complex)}}.every(2)};
     CORRADE_COMPARE(out.str(),
-        "Trade::SceneFieldData: expected second object view dimension size 1, 2, 4 or 8 but got 5\n"
+        "Trade::SceneFieldData: expected second mapping view dimension size 1, 2, 4 or 8 but got 5\n"
         "Trade::SceneFieldData: second field view dimension size 8 doesn't match Trade::SceneFieldType::Vector3\n");
 }
 
@@ -1049,21 +1049,21 @@ void SceneDataTest::constructField2DNonContiguous() {
     CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
     #endif
 
-    char rotationObjectData[8*sizeof(UnsignedInt)];
+    char rotationMappingData[8*sizeof(UnsignedInt)];
     char rotationFieldData[8*sizeof(Complex)];
 
     std::ostringstream out;
     Error redirectError{&out};
     SceneFieldData{SceneField::Rotation,
-        Containers::StridedArrayView2D<char>{rotationObjectData, {4, 2*sizeof(UnsignedInt)}}.every({1, 2}),
+        Containers::StridedArrayView2D<char>{rotationMappingData, {4, 2*sizeof(UnsignedInt)}}.every({1, 2}),
         SceneFieldType::Complex,
         Containers::StridedArrayView2D<char>{rotationFieldData, {4, sizeof(Complex)}}};
     SceneFieldData{SceneField::Rotation,
-        Containers::StridedArrayView2D<char>{rotationObjectData, {4, sizeof(UnsignedInt)}},
+        Containers::StridedArrayView2D<char>{rotationMappingData, {4, sizeof(UnsignedInt)}},
         SceneFieldType::Complex,
         Containers::StridedArrayView2D<char>{rotationFieldData, {4, 2*sizeof(Complex)}}.every({1, 2})};
     CORRADE_COMPARE(out.str(),
-        "Trade::SceneFieldData: second object view dimension is not contiguous\n"
+        "Trade::SceneFieldData: second mapping view dimension is not contiguous\n"
         "Trade::SceneFieldData: second field view dimension is not contiguous\n");
 }
 
@@ -1072,12 +1072,12 @@ void SceneDataTest::constructFieldArrayNonContiguous() {
     CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
     #endif
 
-    UnsignedByte offsetObjectData[3];
+    UnsignedByte offsetMappingData[3];
     Int offsetFieldData[3*4];
 
     std::ostringstream out;
     Error redirectError{&out};
-    SceneFieldData data{sceneFieldCustom(34), Containers::arrayView(offsetObjectData), Containers::StridedArrayView2D<Int>{offsetFieldData, {3, 4}}.every({1, 2})};
+    SceneFieldData data{sceneFieldCustom(34), Containers::arrayView(offsetMappingData), Containers::StridedArrayView2D<Int>{offsetFieldData, {3, 4}}.every({1, 2})};
     CORRADE_COMPARE(out.str(), "Trade::SceneFieldData: second field view dimension is not contiguous\n");
 }
 
@@ -1086,46 +1086,46 @@ void SceneDataTest::constructFieldArrayNotAllowed() {
     CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
     #endif
 
-    UnsignedShort rotationObjectData[3]{};
+    UnsignedShort rotationMappingData[3]{};
     Quaternion rotationFieldData[3];
-    Containers::ArrayView<UnsignedShort> rotationObjects = rotationObjectData;
-    Containers::ArrayView<Quaternion> rotationFields = rotationFieldData;
+    Containers::ArrayView<UnsignedShort> rotationMapping = rotationMappingData;
+    Containers::ArrayView<Quaternion> rotationField = rotationFieldData;
     Containers::StridedArrayView2D<Quaternion> rotationFields2D{rotationFieldData, {3, 3}, {0, sizeof(Quaternion)}};
-    auto rotationFields2DChar = Containers::arrayCast<2, const char>(rotationFields2D);
-    auto rotationObjectsChar = Containers::arrayCast<2, const char>(rotationObjects);
+    auto rotationMappingChar = Containers::arrayCast<2, const char>(rotationMapping);
+    auto rotationField2DChar = Containers::arrayCast<2, const char>(rotationFields2D);
 
     /* This is all fine */
     SceneFieldData{SceneField::Rotation,
-        SceneObjectType::UnsignedShort, rotationObjects,
-        SceneFieldType::Quaternion, rotationFields, 0};
+        SceneMappingType::UnsignedShort, rotationMapping,
+        SceneFieldType::Quaternion, rotationField, 0};
     SceneFieldData{SceneField::Rotation, 3,
-        SceneObjectType::UnsignedShort, 0, sizeof(UnsignedShort),
+        SceneMappingType::UnsignedShort, 0, sizeof(UnsignedShort),
         SceneFieldType::Quaternion, 0, sizeof(Quaternion), 0};
     SceneFieldData{sceneFieldCustom(37),
-        rotationObjects,
+        rotationMapping,
         rotationFields2D};
     SceneFieldData{sceneFieldCustom(37),
-        rotationObjectsChar,
-        SceneFieldType::Quaternion, rotationFields2DChar, 3};
+        rotationMappingChar,
+        SceneFieldType::Quaternion, rotationField2DChar, 3};
     SceneFieldData{sceneFieldCustom(37), 3,
-        SceneObjectType::UnsignedShort, 0, sizeof(UnsignedShort),
+        SceneMappingType::UnsignedShort, 0, sizeof(UnsignedShort),
         SceneFieldType::Quaternion, 0, sizeof(Quaternion), 3};
 
     /* This is not */
     std::ostringstream out;
     Error redirectError{&out};
     SceneFieldData{SceneField::Rotation,
-        SceneObjectType::UnsignedShort, rotationObjects,
-        SceneFieldType::Quaternion, rotationFields, 3};
+        SceneMappingType::UnsignedShort, rotationMapping,
+        SceneFieldType::Quaternion, rotationField, 3};
     SceneFieldData{SceneField::Rotation, 3,
-        SceneObjectType::UnsignedShort, 0, sizeof(UnsignedShort),
+        SceneMappingType::UnsignedShort, 0, sizeof(UnsignedShort),
         SceneFieldType::Quaternion, 0, sizeof(Quaternion), 3};
     SceneFieldData{SceneField::Rotation,
-        rotationObjects,
+        rotationMapping,
         rotationFields2D};
     SceneFieldData{SceneField::Rotation,
-        rotationObjectsChar,
-        SceneFieldType::Quaternion, rotationFields2DChar, 3};
+        rotationMappingChar,
+        SceneFieldType::Quaternion, rotationField2DChar, 3};
     CORRADE_COMPARE(out.str(),
         "Trade::SceneFieldData: Trade::SceneField::Rotation can't be an array field\n"
         "Trade::SceneFieldData: Trade::SceneField::Rotation can't be an array field\n"
@@ -1138,13 +1138,13 @@ void SceneDataTest::constructFieldArray2DWrongSize() {
     CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
     #endif
 
-    char rotationObjectData[4*sizeof(UnsignedInt)];
+    char rotationMappingData[4*sizeof(UnsignedInt)];
     char rotationFieldData[4*sizeof(Complex)];
 
     std::ostringstream out;
     Error redirectError{&out};
     SceneFieldData{sceneFieldCustom(37),
-        Containers::StridedArrayView2D<char>{rotationObjectData, {4, sizeof(UnsignedInt)}}.every(2),
+        Containers::StridedArrayView2D<char>{rotationMappingData, {4, sizeof(UnsignedInt)}}.every(2),
         SceneFieldType::Int,
         Containers::StridedArrayView2D<char>{rotationFieldData, {4, sizeof(Complex)}}.every(2), 3};
     CORRADE_COMPARE(out.str(),
@@ -1156,21 +1156,21 @@ void SceneDataTest::constructFieldArray2DNonContiguous() {
     CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
     #endif
 
-    char offsetObjectData[18*sizeof(UnsignedInt)];
+    char offsetMappingData[18*sizeof(UnsignedInt)];
     char offsetFieldData[18*sizeof(Int)];
 
     std::ostringstream out;
     Error redirectError{&out};
     SceneFieldData{sceneFieldCustom(37),
-        Containers::StridedArrayView2D<char>{offsetObjectData, {3, 2*sizeof(UnsignedInt)}}.every({1, 2}),
+        Containers::StridedArrayView2D<char>{offsetMappingData, {3, 2*sizeof(UnsignedInt)}}.every({1, 2}),
         SceneFieldType::Int,
         Containers::StridedArrayView2D<char>{offsetFieldData, {3, 3*sizeof(Int)}}, 3};
     SceneFieldData{sceneFieldCustom(37),
-        Containers::StridedArrayView2D<char>{offsetObjectData, {3, sizeof(UnsignedInt)}},
+        Containers::StridedArrayView2D<char>{offsetMappingData, {3, sizeof(UnsignedInt)}},
         SceneFieldType::Int,
         Containers::StridedArrayView2D<char>{offsetFieldData, {3, 6*sizeof(Int)}}.every({1, 2}), 3};
     CORRADE_COMPARE(out.str(),
-        "Trade::SceneFieldData: second object view dimension is not contiguous\n"
+        "Trade::SceneFieldData: second mapping view dimension is not contiguous\n"
         "Trade::SceneFieldData: second field view dimension is not contiguous\n");
 }
 
@@ -1181,70 +1181,70 @@ void SceneDataTest::construct() {
         Int parent;
     };
 
-    Containers::StridedArrayView1D<TransformParent> transformsParentFieldObjectData;
+    Containers::StridedArrayView1D<TransformParent> transformsParentFieldMappingData;
     Containers::StridedArrayView1D<UnsignedByte> meshFieldData;
     Containers::StridedArrayView1D<Vector2> radiusFieldData;
-    Containers::StridedArrayView1D<UnsignedShort> materialMeshRadiusObjectData;
+    Containers::StridedArrayView1D<UnsignedShort> materialMeshRadiusMappingData;
     Containers::ArrayTuple data{
-        {NoInit, 5, transformsParentFieldObjectData},
+        {NoInit, 5, transformsParentFieldMappingData},
         {NoInit, 2, meshFieldData},
         {NoInit, 2, radiusFieldData},
-        {NoInit, 2, materialMeshRadiusObjectData},
+        {NoInit, 2, materialMeshRadiusMappingData},
     };
-    transformsParentFieldObjectData[0].object = 4;
-    transformsParentFieldObjectData[0].transformation = Matrix4::translation(Vector3::xAxis(5.0f));
-    transformsParentFieldObjectData[0].parent = -1;
+    transformsParentFieldMappingData[0].object = 4;
+    transformsParentFieldMappingData[0].transformation = Matrix4::translation(Vector3::xAxis(5.0f));
+    transformsParentFieldMappingData[0].parent = -1;
 
-    transformsParentFieldObjectData[1].object = 2;
-    transformsParentFieldObjectData[1].transformation = Matrix4::translation(Vector3::yAxis(5.0f));
-    transformsParentFieldObjectData[1].parent = 0;
+    transformsParentFieldMappingData[1].object = 2;
+    transformsParentFieldMappingData[1].transformation = Matrix4::translation(Vector3::yAxis(5.0f));
+    transformsParentFieldMappingData[1].parent = 0;
 
-    transformsParentFieldObjectData[2].object = 3;
-    transformsParentFieldObjectData[2].transformation = Matrix4::translation(Vector3::zAxis(5.0f));
-    transformsParentFieldObjectData[2].parent = 2;
+    transformsParentFieldMappingData[2].object = 3;
+    transformsParentFieldMappingData[2].transformation = Matrix4::translation(Vector3::zAxis(5.0f));
+    transformsParentFieldMappingData[2].parent = 2;
 
-    transformsParentFieldObjectData[3].object = 0;
-    transformsParentFieldObjectData[3].transformation = Matrix4::translation(Vector3::yScale(5.0f));
-    transformsParentFieldObjectData[3].parent = 1;
+    transformsParentFieldMappingData[3].object = 0;
+    transformsParentFieldMappingData[3].transformation = Matrix4::translation(Vector3::yScale(5.0f));
+    transformsParentFieldMappingData[3].parent = 1;
 
-    transformsParentFieldObjectData[4].object = 1;
-    transformsParentFieldObjectData[4].transformation = Matrix4::translation(Vector3::zScale(5.0f));
-    transformsParentFieldObjectData[4].parent = -1;
+    transformsParentFieldMappingData[4].object = 1;
+    transformsParentFieldMappingData[4].transformation = Matrix4::translation(Vector3::zScale(5.0f));
+    transformsParentFieldMappingData[4].parent = -1;
 
     meshFieldData[0] = 5;
     radiusFieldData[0] = {37.5f, 1.5f};
-    materialMeshRadiusObjectData[0] = 2;
+    materialMeshRadiusMappingData[0] = 2;
 
     meshFieldData[1] = 7;
     radiusFieldData[1] = {22.5f, 0.5f};
-    materialMeshRadiusObjectData[1] = 6;
+    materialMeshRadiusMappingData[1] = 6;
 
     int importerState;
     SceneFieldData transformations{SceneField::Transformation,
-        transformsParentFieldObjectData.slice(&TransformParent::object),
-        transformsParentFieldObjectData.slice(&TransformParent::transformation)};
+        transformsParentFieldMappingData.slice(&TransformParent::object),
+        transformsParentFieldMappingData.slice(&TransformParent::transformation)};
     /* Offset-only */
     SceneFieldData parents{SceneField::Parent, 5,
-        SceneObjectType::UnsignedShort, offsetof(TransformParent, object), sizeof(TransformParent),
+        SceneMappingType::UnsignedShort, offsetof(TransformParent, object), sizeof(TransformParent),
         SceneFieldType::Int, offsetof(TransformParent, parent), sizeof(TransformParent)};
     SceneFieldData meshes{SceneField::Mesh,
-        materialMeshRadiusObjectData,
+        materialMeshRadiusMappingData,
         meshFieldData};
     /* Custom & array */
     SceneFieldData radiuses{sceneFieldCustom(37),
-        materialMeshRadiusObjectData,
+        materialMeshRadiusMappingData,
         Containers::arrayCast<2, Float>(radiusFieldData)};
-    SceneData scene{SceneObjectType::UnsignedShort, 8, std::move(data), {
+    SceneData scene{SceneMappingType::UnsignedShort, 8, std::move(data), {
         transformations, parents, meshes, radiuses
     }, &importerState};
 
     /* Basics */
     CORRADE_COMPARE(scene.dataFlags(), DataFlag::Owned|DataFlag::Mutable);
     CORRADE_VERIFY(!scene.fieldData().empty());
-    CORRADE_COMPARE(static_cast<const void*>(scene.data()), transformsParentFieldObjectData.data());
-    CORRADE_COMPARE(static_cast<void*>(scene.mutableData()), transformsParentFieldObjectData.data());
-    CORRADE_COMPARE(scene.objectCount(), 8);
-    CORRADE_COMPARE(scene.objectType(), SceneObjectType::UnsignedShort);
+    CORRADE_COMPARE(static_cast<const void*>(scene.data()), transformsParentFieldMappingData.data());
+    CORRADE_COMPARE(static_cast<void*>(scene.mutableData()), transformsParentFieldMappingData.data());
+    CORRADE_COMPARE(scene.mappingBound(), 8);
+    CORRADE_COMPARE(scene.mappingType(), SceneMappingType::UnsignedShort);
     CORRADE_COMPARE(scene.fieldCount(), 4);
     CORRADE_COMPARE(scene.importerState(), &importerState);
 
@@ -1272,8 +1272,8 @@ void SceneDataTest::construct() {
     /* Raw field data access by ID */
     CORRADE_COMPARE(scene.fieldData(2).name(), SceneField::Mesh);
     CORRADE_COMPARE(scene.fieldData(2).size(), 2);
-    CORRADE_COMPARE(scene.fieldData(2).objectType(), SceneObjectType::UnsignedShort);
-    CORRADE_COMPARE(Containers::arrayCast<const UnsignedShort>(scene.fieldData(2).objectData())[1], 6);
+    CORRADE_COMPARE(scene.fieldData(2).mappingType(), SceneMappingType::UnsignedShort);
+    CORRADE_COMPARE(Containers::arrayCast<const UnsignedShort>(scene.fieldData(2).mappingData())[1], 6);
     CORRADE_COMPARE(Containers::arrayCast<const UnsignedByte>(scene.fieldData(2).fieldData())[1], 7);
     CORRADE_VERIFY(!scene.fieldData(2).isOffsetOnly());
     CORRADE_COMPARE(scene.fieldData(2).fieldType(), SceneFieldType::UnsignedByte);
@@ -1281,39 +1281,39 @@ void SceneDataTest::construct() {
     /* Offset-only */
     CORRADE_COMPARE(scene.fieldData(1).name(), SceneField::Parent);
     CORRADE_COMPARE(scene.fieldData(1).size(), 5);
-    CORRADE_COMPARE(scene.fieldData(1).objectType(), SceneObjectType::UnsignedShort);
+    CORRADE_COMPARE(scene.fieldData(1).mappingType(), SceneMappingType::UnsignedShort);
     CORRADE_VERIFY(!scene.fieldData(1).isOffsetOnly());
     CORRADE_COMPARE(scene.fieldData(1).fieldType(), SceneFieldType::Int);
     CORRADE_COMPARE(scene.fieldData(1).fieldArraySize(), 0);
-    CORRADE_COMPARE(Containers::arrayCast<const UnsignedShort>(scene.fieldData(1).objectData())[4], 1);
+    CORRADE_COMPARE(Containers::arrayCast<const UnsignedShort>(scene.fieldData(1).mappingData())[4], 1);
     CORRADE_COMPARE(Containers::arrayCast<const Int>(scene.fieldData(1).fieldData())[4], -1);
     /* Array */
     CORRADE_COMPARE(scene.fieldData(3).name(), sceneFieldCustom(37));
     CORRADE_COMPARE(scene.fieldData(3).size(), 2);
-    CORRADE_COMPARE(scene.fieldData(3).objectType(), SceneObjectType::UnsignedShort);
+    CORRADE_COMPARE(scene.fieldData(3).mappingType(), SceneMappingType::UnsignedShort);
     CORRADE_VERIFY(!scene.fieldData(3).isOffsetOnly());
     CORRADE_COMPARE(scene.fieldData(3).fieldType(), SceneFieldType::Float);
     CORRADE_COMPARE(scene.fieldData(3).fieldArraySize(), 2);
-    CORRADE_COMPARE(Containers::arrayCast<const UnsignedShort>(scene.fieldData(3).objectData())[0], 2);
+    CORRADE_COMPARE(Containers::arrayCast<const UnsignedShort>(scene.fieldData(3).mappingData())[0], 2);
     CORRADE_COMPARE(Containers::arrayCast<const Vector2>(scene.fieldData(3).fieldData())[0], (Vector2{37.5f, 1.5f}));
 
-    /* Typeless object access by ID with a cast later */
-    CORRADE_COMPARE(scene.objects(0).size()[0], 5);
-    CORRADE_COMPARE(scene.objects(1).size()[0], 5);
-    CORRADE_COMPARE(scene.objects(2).size()[0], 2);
-    CORRADE_COMPARE(scene.objects(3).size()[0], 2);
-    CORRADE_COMPARE(scene.mutableObjects(0).size()[0], 5);
-    CORRADE_COMPARE(scene.mutableObjects(1).size()[0], 5);
-    CORRADE_COMPARE(scene.mutableObjects(2).size()[0], 2);
-    CORRADE_COMPARE(scene.mutableObjects(3).size()[0], 2);
-    CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedShort>(scene.objects(0))[2]), 3);
-    CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedShort>(scene.objects(1))[4]), 1);
-    CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedShort>(scene.objects(2))[1]), 6);
-    CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedShort>(scene.objects(3))[0]), 2);
-    CORRADE_COMPARE((Containers::arrayCast<1, UnsignedShort>(scene.mutableObjects(0))[2]), 3);
-    CORRADE_COMPARE((Containers::arrayCast<1, UnsignedShort>(scene.mutableObjects(1))[4]), 1);
-    CORRADE_COMPARE((Containers::arrayCast<1, UnsignedShort>(scene.mutableObjects(2))[1]), 6);
-    CORRADE_COMPARE((Containers::arrayCast<1, UnsignedShort>(scene.mutableObjects(3))[0]), 2);
+    /* Typeless mapping access by ID with a cast later */
+    CORRADE_COMPARE(scene.mapping(0).size()[0], 5);
+    CORRADE_COMPARE(scene.mapping(1).size()[0], 5);
+    CORRADE_COMPARE(scene.mapping(2).size()[0], 2);
+    CORRADE_COMPARE(scene.mapping(3).size()[0], 2);
+    CORRADE_COMPARE(scene.mutableMapping(0).size()[0], 5);
+    CORRADE_COMPARE(scene.mutableMapping(1).size()[0], 5);
+    CORRADE_COMPARE(scene.mutableMapping(2).size()[0], 2);
+    CORRADE_COMPARE(scene.mutableMapping(3).size()[0], 2);
+    CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedShort>(scene.mapping(0))[2]), 3);
+    CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedShort>(scene.mapping(1))[4]), 1);
+    CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedShort>(scene.mapping(2))[1]), 6);
+    CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedShort>(scene.mapping(3))[0]), 2);
+    CORRADE_COMPARE((Containers::arrayCast<1, UnsignedShort>(scene.mutableMapping(0))[2]), 3);
+    CORRADE_COMPARE((Containers::arrayCast<1, UnsignedShort>(scene.mutableMapping(1))[4]), 1);
+    CORRADE_COMPARE((Containers::arrayCast<1, UnsignedShort>(scene.mutableMapping(2))[1]), 6);
+    CORRADE_COMPARE((Containers::arrayCast<1, UnsignedShort>(scene.mutableMapping(3))[0]), 2);
 
     /* Typeless field access by ID with a cast later */
     CORRADE_COMPARE(scene.field(0).size()[0], 5);
@@ -1333,23 +1333,23 @@ void SceneDataTest::construct() {
     CORRADE_COMPARE((Containers::arrayCast<1, UnsignedByte>(scene.mutableField(2))[1]), 7);
     CORRADE_COMPARE((Containers::arrayCast<1, Vector2>(scene.mutableField(3))[0]), (Vector2{37.5f, 1.5f}));
 
-    /* Typed object access by ID */
-    CORRADE_COMPARE(scene.objects<UnsignedShort>(0).size(), 5);
-    CORRADE_COMPARE(scene.objects<UnsignedShort>(1).size(), 5);
-    CORRADE_COMPARE(scene.objects<UnsignedShort>(2).size(), 2);
-    CORRADE_COMPARE(scene.objects<UnsignedShort>(3).size(), 2);
-    CORRADE_COMPARE(scene.mutableObjects<UnsignedShort>(0).size(), 5);
-    CORRADE_COMPARE(scene.mutableObjects<UnsignedShort>(1).size(), 5);
-    CORRADE_COMPARE(scene.mutableObjects<UnsignedShort>(2).size(), 2);
-    CORRADE_COMPARE(scene.mutableObjects<UnsignedShort>(3).size(), 2);
-    CORRADE_COMPARE(scene.objects<UnsignedShort>(0)[2], 3);
-    CORRADE_COMPARE(scene.objects<UnsignedShort>(1)[4], 1);
-    CORRADE_COMPARE(scene.objects<UnsignedShort>(2)[1], 6);
-    CORRADE_COMPARE(scene.objects<UnsignedShort>(3)[0], 2);
-    CORRADE_COMPARE(scene.mutableObjects<UnsignedShort>(0)[2], 3);
-    CORRADE_COMPARE(scene.mutableObjects<UnsignedShort>(1)[4], 1);
-    CORRADE_COMPARE(scene.mutableObjects<UnsignedShort>(2)[1], 6);
-    CORRADE_COMPARE(scene.mutableObjects<UnsignedShort>(3)[0], 2);
+    /* Typed mapping access by ID */
+    CORRADE_COMPARE(scene.mapping<UnsignedShort>(0).size(), 5);
+    CORRADE_COMPARE(scene.mapping<UnsignedShort>(1).size(), 5);
+    CORRADE_COMPARE(scene.mapping<UnsignedShort>(2).size(), 2);
+    CORRADE_COMPARE(scene.mapping<UnsignedShort>(3).size(), 2);
+    CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(0).size(), 5);
+    CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(1).size(), 5);
+    CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(2).size(), 2);
+    CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(3).size(), 2);
+    CORRADE_COMPARE(scene.mapping<UnsignedShort>(0)[2], 3);
+    CORRADE_COMPARE(scene.mapping<UnsignedShort>(1)[4], 1);
+    CORRADE_COMPARE(scene.mapping<UnsignedShort>(2)[1], 6);
+    CORRADE_COMPARE(scene.mapping<UnsignedShort>(3)[0], 2);
+    CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(0)[2], 3);
+    CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(1)[4], 1);
+    CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(2)[1], 6);
+    CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(3)[0], 2);
 
     /* Typed field access by ID */
     CORRADE_COMPARE(scene.field<Matrix4>(0).size(), 5);
@@ -1387,23 +1387,23 @@ void SceneDataTest::construct() {
     CORRADE_COMPARE(scene.fieldArraySize(SceneField::Mesh), 0);
     CORRADE_COMPARE(scene.fieldArraySize(sceneFieldCustom(37)), 2);
 
-    /* Typeless object access by name with a cast later */
-    CORRADE_COMPARE(scene.objects(SceneField::Transformation).size()[0], 5);
-    CORRADE_COMPARE(scene.objects(SceneField::Parent).size()[0], 5);
-    CORRADE_COMPARE(scene.objects(2).size()[0], 2);
-    CORRADE_COMPARE(scene.objects(3).size()[0], 2);
-    CORRADE_COMPARE(scene.mutableObjects(SceneField::Transformation).size()[0], 5);
-    CORRADE_COMPARE(scene.mutableObjects(SceneField::Parent).size()[0], 5);
-    CORRADE_COMPARE(scene.mutableObjects(2).size()[0], 2);
-    CORRADE_COMPARE(scene.mutableObjects(3).size()[0], 2);
-    CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedShort>(scene.objects(SceneField::Transformation))[2]), 3);
-    CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedShort>(scene.objects(SceneField::Parent))[4]), 1);
-    CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedShort>(scene.objects(2))[1]), 6);
-    CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedShort>(scene.objects(3))[0]), 2);
-    CORRADE_COMPARE((Containers::arrayCast<1, UnsignedShort>(scene.mutableObjects(SceneField::Transformation))[2]), 3);
-    CORRADE_COMPARE((Containers::arrayCast<1, UnsignedShort>(scene.mutableObjects(SceneField::Parent))[4]), 1);
-    CORRADE_COMPARE((Containers::arrayCast<1, UnsignedShort>(scene.mutableObjects(2))[1]), 6);
-    CORRADE_COMPARE((Containers::arrayCast<1, UnsignedShort>(scene.mutableObjects(3))[0]), 2);
+    /* Typeless mapping access by name with a cast later */
+    CORRADE_COMPARE(scene.mapping(SceneField::Transformation).size()[0], 5);
+    CORRADE_COMPARE(scene.mapping(SceneField::Parent).size()[0], 5);
+    CORRADE_COMPARE(scene.mapping(2).size()[0], 2);
+    CORRADE_COMPARE(scene.mapping(3).size()[0], 2);
+    CORRADE_COMPARE(scene.mutableMapping(SceneField::Transformation).size()[0], 5);
+    CORRADE_COMPARE(scene.mutableMapping(SceneField::Parent).size()[0], 5);
+    CORRADE_COMPARE(scene.mutableMapping(2).size()[0], 2);
+    CORRADE_COMPARE(scene.mutableMapping(3).size()[0], 2);
+    CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedShort>(scene.mapping(SceneField::Transformation))[2]), 3);
+    CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedShort>(scene.mapping(SceneField::Parent))[4]), 1);
+    CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedShort>(scene.mapping(2))[1]), 6);
+    CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedShort>(scene.mapping(3))[0]), 2);
+    CORRADE_COMPARE((Containers::arrayCast<1, UnsignedShort>(scene.mutableMapping(SceneField::Transformation))[2]), 3);
+    CORRADE_COMPARE((Containers::arrayCast<1, UnsignedShort>(scene.mutableMapping(SceneField::Parent))[4]), 1);
+    CORRADE_COMPARE((Containers::arrayCast<1, UnsignedShort>(scene.mutableMapping(2))[1]), 6);
+    CORRADE_COMPARE((Containers::arrayCast<1, UnsignedShort>(scene.mutableMapping(3))[0]), 2);
 
     /* Typeless field access by name with a cast later */
     CORRADE_COMPARE(scene.field(SceneField::Transformation).size()[0], 5);
@@ -1423,23 +1423,23 @@ void SceneDataTest::construct() {
     CORRADE_COMPARE((Containers::arrayCast<1, UnsignedByte>(scene.mutableField(SceneField::Mesh))[1]), 7);
     CORRADE_COMPARE((Containers::arrayCast<1, Vector2>(scene.mutableField(sceneFieldCustom(37)))[0]), (Vector2{37.5f, 1.5f}));
 
-    /* Typed object access by name */
-    CORRADE_COMPARE(scene.objects<UnsignedShort>(SceneField::Transformation).size(), 5);
-    CORRADE_COMPARE(scene.objects<UnsignedShort>(SceneField::Parent).size(), 5);
-    CORRADE_COMPARE(scene.objects<UnsignedShort>(SceneField::Mesh).size(), 2);
-    CORRADE_COMPARE(scene.objects<UnsignedShort>(sceneFieldCustom(37)).size(), 2);
-    CORRADE_COMPARE(scene.mutableObjects<UnsignedShort>(SceneField::Transformation).size(), 5);
-    CORRADE_COMPARE(scene.mutableObjects<UnsignedShort>(SceneField::Parent).size(), 5);
-    CORRADE_COMPARE(scene.mutableObjects<UnsignedShort>(SceneField::Mesh).size(), 2);
-    CORRADE_COMPARE(scene.mutableObjects<UnsignedShort>(sceneFieldCustom(37)).size(), 2);
-    CORRADE_COMPARE(scene.objects<UnsignedShort>(SceneField::Transformation)[2], 3);
-    CORRADE_COMPARE(scene.objects<UnsignedShort>(SceneField::Parent)[4], 1);
-    CORRADE_COMPARE(scene.objects<UnsignedShort>(SceneField::Mesh)[1], 6);
-    CORRADE_COMPARE(scene.objects<UnsignedShort>(sceneFieldCustom(37))[0], 2);
-    CORRADE_COMPARE(scene.mutableObjects<UnsignedShort>(SceneField::Transformation)[2], 3);
-    CORRADE_COMPARE(scene.mutableObjects<UnsignedShort>(SceneField::Parent)[4], 1);
-    CORRADE_COMPARE(scene.mutableObjects<UnsignedShort>(SceneField::Mesh)[1], 6);
-    CORRADE_COMPARE(scene.mutableObjects<UnsignedShort>(sceneFieldCustom(37))[0], 2);
+    /* Typed mapping access by name */
+    CORRADE_COMPARE(scene.mapping<UnsignedShort>(SceneField::Transformation).size(), 5);
+    CORRADE_COMPARE(scene.mapping<UnsignedShort>(SceneField::Parent).size(), 5);
+    CORRADE_COMPARE(scene.mapping<UnsignedShort>(SceneField::Mesh).size(), 2);
+    CORRADE_COMPARE(scene.mapping<UnsignedShort>(sceneFieldCustom(37)).size(), 2);
+    CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(SceneField::Transformation).size(), 5);
+    CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(SceneField::Parent).size(), 5);
+    CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(SceneField::Mesh).size(), 2);
+    CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(sceneFieldCustom(37)).size(), 2);
+    CORRADE_COMPARE(scene.mapping<UnsignedShort>(SceneField::Transformation)[2], 3);
+    CORRADE_COMPARE(scene.mapping<UnsignedShort>(SceneField::Parent)[4], 1);
+    CORRADE_COMPARE(scene.mapping<UnsignedShort>(SceneField::Mesh)[1], 6);
+    CORRADE_COMPARE(scene.mapping<UnsignedShort>(sceneFieldCustom(37))[0], 2);
+    CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(SceneField::Transformation)[2], 3);
+    CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(SceneField::Parent)[4], 1);
+    CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(SceneField::Mesh)[1], 6);
+    CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(sceneFieldCustom(37))[0], 2);
 
     /* Typed field access by name */
     CORRADE_COMPARE(scene.field<Matrix4>(SceneField::Transformation).size(), 5);
@@ -1466,14 +1466,14 @@ void SceneDataTest::construct() {
 
 void SceneDataTest::constructZeroFields() {
     int importerState;
-    SceneData scene{SceneObjectType::UnsignedShort, 37563, nullptr, {}, &importerState};
+    SceneData scene{SceneMappingType::UnsignedShort, 37563, nullptr, {}, &importerState};
     CORRADE_COMPARE(scene.dataFlags(), DataFlag::Owned|DataFlag::Mutable);
     CORRADE_VERIFY(scene.fieldData().empty());
     CORRADE_COMPARE(static_cast<const void*>(scene.data()), nullptr);
     CORRADE_COMPARE(static_cast<void*>(scene.mutableData()), nullptr);
     CORRADE_COMPARE(scene.importerState(), &importerState);
-    CORRADE_COMPARE(scene.objectCount(), 37563);
-    CORRADE_COMPARE(scene.objectType(), SceneObjectType::UnsignedShort);
+    CORRADE_COMPARE(scene.mappingBound(), 37563);
+    CORRADE_COMPARE(scene.mappingType(), SceneMappingType::UnsignedShort);
     CORRADE_COMPARE(scene.fieldCount(), 0);
     CORRADE_VERIFY(!scene.is2D());
     CORRADE_VERIFY(!scene.is3D());
@@ -1481,16 +1481,16 @@ void SceneDataTest::constructZeroFields() {
 
 void SceneDataTest::constructZeroObjects() {
     int importerState;
-    SceneFieldData meshes{SceneField::Mesh, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::UnsignedShort, nullptr};
-    SceneFieldData materials{SceneField::MeshMaterial, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr};
-    SceneData scene{SceneObjectType::UnsignedInt, 0, nullptr, {meshes, materials}, &importerState};
+    SceneFieldData meshes{SceneField::Mesh, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::UnsignedShort, nullptr};
+    SceneFieldData materials{SceneField::MeshMaterial, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr};
+    SceneData scene{SceneMappingType::UnsignedInt, 0, nullptr, {meshes, materials}, &importerState};
     CORRADE_COMPARE(scene.dataFlags(), DataFlag::Owned|DataFlag::Mutable);
     CORRADE_VERIFY(!scene.fieldData().empty());
     CORRADE_COMPARE(static_cast<const void*>(scene.data()), nullptr);
     CORRADE_COMPARE(static_cast<void*>(scene.mutableData()), nullptr);
     CORRADE_COMPARE(scene.importerState(), &importerState);
-    CORRADE_COMPARE(scene.objectCount(), 0);
-    CORRADE_COMPARE(scene.objectType(), SceneObjectType::UnsignedInt);
+    CORRADE_COMPARE(scene.mappingBound(), 0);
+    CORRADE_COMPARE(scene.mappingType(), SceneMappingType::UnsignedInt);
     CORRADE_COMPARE(scene.fieldCount(), 2);
 
     /* Field property access by name */
@@ -1498,8 +1498,8 @@ void SceneDataTest::constructZeroObjects() {
     CORRADE_COMPARE(scene.fieldType(SceneField::MeshMaterial), SceneFieldType::Int);
     CORRADE_COMPARE(scene.fieldSize(SceneField::Mesh), 0);
     CORRADE_COMPARE(scene.fieldSize(SceneField::MeshMaterial), 0);
-    CORRADE_COMPARE(scene.objects(SceneField::Mesh).data(), nullptr);
-    CORRADE_COMPARE(scene.objects(SceneField::MeshMaterial).data(), nullptr);
+    CORRADE_COMPARE(scene.mapping(SceneField::Mesh).data(), nullptr);
+    CORRADE_COMPARE(scene.mapping(SceneField::MeshMaterial).data(), nullptr);
 }
 
 void SceneDataTest::constructSpecialStrides() {
@@ -1516,31 +1516,31 @@ void SceneDataTest::constructSpecialStrides() {
     nonBroadcastedData[2] = 3;
     nonBroadcastedData[3] = 4;
 
-    SceneFieldData broadcastedObjects{sceneFieldCustom(38),
+    SceneFieldData broadcastedMapping{sceneFieldCustom(38),
         broadcastedData.broadcasted<0>(4), nonBroadcastedData};
-    SceneFieldData broadcastedFields{sceneFieldCustom(39),
+    SceneFieldData broadcastedField{sceneFieldCustom(39),
         nonBroadcastedData, broadcastedData.broadcasted<0>(4)};
-    SceneFieldData flippedFields{sceneFieldCustom(40),
+    SceneFieldData flippedField{sceneFieldCustom(40),
         nonBroadcastedData.flipped<0>(), nonBroadcastedData.flipped<0>()};
-    SceneData scene{SceneObjectType::UnsignedShort, 8, std::move(data), {
-        broadcastedObjects, broadcastedFields, flippedFields
+    SceneData scene{SceneMappingType::UnsignedShort, 8, std::move(data), {
+        broadcastedMapping, broadcastedField, flippedField
     }};
 
-    CORRADE_COMPARE_AS(scene.objects<UnsignedShort>(0),
+    CORRADE_COMPARE_AS(scene.mapping<UnsignedShort>(0),
         Containers::arrayView<UnsignedShort>({15, 15, 15, 15}),
         TestSuite::Compare::Container);
     CORRADE_COMPARE_AS(scene.field<UnsignedShort>(0),
         Containers::arrayView<UnsignedShort>({1, 2, 3, 4}),
         TestSuite::Compare::Container);
 
-    CORRADE_COMPARE_AS(scene.objects<UnsignedShort>(1),
+    CORRADE_COMPARE_AS(scene.mapping<UnsignedShort>(1),
         Containers::arrayView<UnsignedShort>({1, 2, 3, 4}),
         TestSuite::Compare::Container);
     CORRADE_COMPARE_AS(scene.field<UnsignedShort>(1),
         Containers::arrayView<UnsignedShort>({15, 15, 15, 15}),
         TestSuite::Compare::Container);
 
-    CORRADE_COMPARE_AS(scene.objects<UnsignedShort>(2),
+    CORRADE_COMPARE_AS(scene.mapping<UnsignedShort>(2),
         Containers::arrayView<UnsignedShort>({4, 3, 2, 1}),
         TestSuite::Compare::Container);
     CORRADE_COMPARE_AS(scene.field<UnsignedShort>(2),
@@ -1565,21 +1565,21 @@ void SceneDataTest::constructNotOwned() {
     SceneFieldData mesh{SceneField::Mesh,
         Containers::stridedArrayView(data).slice(&Data::object),
         Containers::stridedArrayView(data).slice(&Data::mesh)};
-    SceneData scene{SceneObjectType::UnsignedShort, 7, instanceData.dataFlags, Containers::arrayView(data), {mesh}, &importerState};
+    SceneData scene{SceneMappingType::UnsignedShort, 7, instanceData.dataFlags, Containers::arrayView(data), {mesh}, &importerState};
 
     CORRADE_COMPARE(scene.dataFlags(), instanceData.dataFlags);
     CORRADE_COMPARE(static_cast<const void*>(scene.data()), +data);
     if(instanceData.dataFlags & DataFlag::Mutable)
         CORRADE_COMPARE(static_cast<void*>(scene.mutableData()), static_cast<void*>(data));
-    CORRADE_COMPARE(scene.objectCount(), 7);
-    CORRADE_COMPARE(scene.objectType(), SceneObjectType::UnsignedShort);
+    CORRADE_COMPARE(scene.mappingBound(), 7);
+    CORRADE_COMPARE(scene.mappingType(), SceneMappingType::UnsignedShort);
     CORRADE_COMPARE(scene.fieldCount(), 1);
     CORRADE_COMPARE(scene.importerState(), &importerState);
 
-    CORRADE_COMPARE(scene.objects<UnsignedShort>(0).size(), 3);
-    CORRADE_COMPARE(scene.objects<UnsignedShort>(0)[2], 2);
+    CORRADE_COMPARE(scene.mapping<UnsignedShort>(0).size(), 3);
+    CORRADE_COMPARE(scene.mapping<UnsignedShort>(0)[2], 2);
     if(instanceData.dataFlags & DataFlag::Mutable)
-        CORRADE_COMPARE(scene.mutableObjects<UnsignedShort>(0)[2], 2);
+        CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(0)[2], 2);
 
     CORRADE_COMPARE(scene.field<UnsignedByte>(0).size(), 3);
     CORRADE_COMPARE(scene.field<UnsignedByte>(0)[2], 0);
@@ -1599,18 +1599,18 @@ void SceneDataTest::constructDeprecated() {
         data.is3D ? std::vector<UnsignedInt>{5, 17, 36, 22} : std::vector<UnsignedInt>{},
         &a};
     CORRADE_IGNORE_DEPRECATED_POP
-    CORRADE_COMPARE(scene.objectType(), SceneObjectType::UnsignedInt);
+    CORRADE_COMPARE(scene.mappingType(), SceneMappingType::UnsignedInt);
     if(data.is2D || data.is3D)
-        CORRADE_COMPARE(scene.objectCount(), 37);
+        CORRADE_COMPARE(scene.mappingBound(), 37);
     else
-        CORRADE_COMPARE(scene.objectCount(), 0);
+        CORRADE_COMPARE(scene.mappingBound(), 0);
     CORRADE_COMPARE(scene.dataFlags(), DataFlag::Mutable|DataFlag::Owned);
     CORRADE_COMPARE(scene.importerState(), &a);
     CORRADE_COMPARE(scene.fieldCount(), 1);
     CORRADE_COMPARE(scene.fieldName(0), SceneField::Parent);
     CORRADE_COMPARE(scene.fieldType(0), SceneFieldType::Int);
     if(data.is2D || data.is3D) {
-        CORRADE_COMPARE_AS(scene.objects<UnsignedInt>(0),
+        CORRADE_COMPARE_AS(scene.mapping<UnsignedInt>(0),
             Containers::arrayView<UnsignedInt>({5, 17, 36, 22}),
             TestSuite::Compare::Container);
         CORRADE_COMPARE_AS(scene.field<Int>(0),
@@ -1649,13 +1649,13 @@ void SceneDataTest::constructDuplicateField() {
 
     /* Builtin fields are checked using a bitfield, as they have monotonic
        numbering */
-    SceneFieldData meshes{SceneField::Mesh, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::UnsignedShort, nullptr};
-    SceneFieldData materials{SceneField::MeshMaterial, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr};
-    SceneFieldData meshesAgain{SceneField::Mesh, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::UnsignedInt, nullptr};
+    SceneFieldData meshes{SceneField::Mesh, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::UnsignedShort, nullptr};
+    SceneFieldData materials{SceneField::MeshMaterial, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr};
+    SceneFieldData meshesAgain{SceneField::Mesh, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::UnsignedInt, nullptr};
 
     std::ostringstream out;
     Error redirectError{&out};
-    SceneData scene{SceneObjectType::UnsignedInt, 0, nullptr, {meshes, materials, meshesAgain}};
+    SceneData scene{SceneMappingType::UnsignedInt, 0, nullptr, {meshes, materials, meshesAgain}};
     CORRADE_COMPARE(out.str(), "Trade::SceneData: duplicate field Trade::SceneField::Mesh\n");
 }
 
@@ -1666,31 +1666,31 @@ void SceneDataTest::constructDuplicateCustomField() {
 
     /* These are checked in an O(n^2) way, separately from builtin fields.
        Can't use a bitfield since the field index can be anything. */
-    SceneFieldData customA{sceneFieldCustom(37), SceneObjectType::UnsignedInt, nullptr, SceneFieldType::UnsignedShort, nullptr};
-    SceneFieldData customB{sceneFieldCustom(1038576154), SceneObjectType::UnsignedInt, nullptr, SceneFieldType::UnsignedInt, nullptr};
-    SceneFieldData customAAgain{sceneFieldCustom(37), SceneObjectType::UnsignedInt, nullptr, SceneFieldType::UnsignedInt, nullptr};
+    SceneFieldData customA{sceneFieldCustom(37), SceneMappingType::UnsignedInt, nullptr, SceneFieldType::UnsignedShort, nullptr};
+    SceneFieldData customB{sceneFieldCustom(1038576154), SceneMappingType::UnsignedInt, nullptr, SceneFieldType::UnsignedInt, nullptr};
+    SceneFieldData customAAgain{sceneFieldCustom(37), SceneMappingType::UnsignedInt, nullptr, SceneFieldType::UnsignedInt, nullptr};
 
     std::ostringstream out;
     Error redirectError{&out};
-    SceneData scene{SceneObjectType::UnsignedInt, 0, nullptr, {customA, customB, customAAgain}};
+    SceneData scene{SceneMappingType::UnsignedInt, 0, nullptr, {customA, customB, customAAgain}};
     CORRADE_COMPARE(out.str(), "Trade::SceneData: duplicate field Trade::SceneField::Custom(37)\n");
 }
 
-void SceneDataTest::constructInconsistentObjectType() {
+void SceneDataTest::constructInconsistentMappingType() {
     #ifdef CORRADE_NO_ASSERT
     CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
     #endif
 
-    SceneFieldData meshes{SceneField::Mesh, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::UnsignedShort, nullptr};
-    SceneFieldData materials{SceneField::MeshMaterial, SceneObjectType::UnsignedShort, nullptr, SceneFieldType::Int, nullptr};
+    SceneFieldData meshes{SceneField::Mesh, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::UnsignedShort, nullptr};
+    SceneFieldData materials{SceneField::MeshMaterial, SceneMappingType::UnsignedShort, nullptr, SceneFieldType::Int, nullptr};
 
     std::ostringstream out;
     Error redirectError{&out};
-    SceneData scene{SceneObjectType::UnsignedInt, 0, nullptr, {meshes, materials}};
-    CORRADE_COMPARE(out.str(), "Trade::SceneData: inconsistent object type, got Trade::SceneObjectType::UnsignedShort for field 1 but expected Trade::SceneObjectType::UnsignedInt\n");
+    SceneData scene{SceneMappingType::UnsignedInt, 0, nullptr, {meshes, materials}};
+    CORRADE_COMPARE(out.str(), "Trade::SceneData: inconsistent mapping type, got Trade::SceneMappingType::UnsignedShort for field 1 but expected Trade::SceneMappingType::UnsignedInt\n");
 }
 
-void SceneDataTest::constructObjectDataNotContained() {
+void SceneDataTest::constructMappingDataNotContained() {
     #ifdef CORRADE_NO_ASSERT
     CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
     #endif
@@ -1703,35 +1703,35 @@ void SceneDataTest::constructObjectDataNotContained() {
     std::ostringstream out;
     Error redirectError{&out};
     /* First a "slightly off" view that exceeds the original by one byte */
-    SceneData{SceneObjectType::UnsignedShort, 5, {}, data, {
+    SceneData{SceneMappingType::UnsignedShort, 5, {}, data, {
         SceneFieldData{SceneField::Mesh, dataSlightlyOut, dataIn}
     }};
     /* Second a view that's in a completely different location */
-    SceneData{SceneObjectType::UnsignedShort, 5, {}, data, {
+    SceneData{SceneMappingType::UnsignedShort, 5, {}, data, {
         SceneFieldData{SceneField::Light, dataIn, dataIn},
         SceneFieldData{SceneField::Mesh, dataOut, dataIn}
     }};
     /* Verify the owning constructor does the checks as well */
-    SceneData{SceneObjectType::UnsignedShort, 5, std::move(data), {
+    SceneData{SceneMappingType::UnsignedShort, 5, std::move(data), {
         SceneFieldData{SceneField::Light, dataIn, dataIn},
         SceneFieldData{SceneField::Mesh, dataOut, dataIn}
     }};
     /* And if we have no data at all, it doesn't try to dereference them but
        still checks properly */
-    SceneData{SceneObjectType::UnsignedShort, 5, nullptr, {
+    SceneData{SceneMappingType::UnsignedShort, 5, nullptr, {
         SceneFieldData{SceneField::Mesh, dataOut, dataIn}
     }};
     /* Finally, offset-only fields with a different message */
-    SceneData{SceneObjectType::UnsignedByte, 6, Containers::Array<char>{24}, {
-        SceneFieldData{SceneField::Mesh, 6, SceneObjectType::UnsignedByte, 4, 4, SceneFieldType::UnsignedByte, 0, 4}
+    SceneData{SceneMappingType::UnsignedByte, 6, Containers::Array<char>{24}, {
+        SceneFieldData{SceneField::Mesh, 6, SceneMappingType::UnsignedByte, 4, 4, SceneFieldType::UnsignedByte, 0, 4}
     }};
     CORRADE_COMPARE(out.str(),
-        "Trade::SceneData: object data [0xbaddaa:0xbaddb4] of field 0 are not contained in passed data array [0xbadda9:0xbaddb3]\n"
-        "Trade::SceneData: object data [0xdead:0xdeb7] of field 1 are not contained in passed data array [0xbadda9:0xbaddb3]\n"
-        "Trade::SceneData: object data [0xdead:0xdeb7] of field 1 are not contained in passed data array [0xbadda9:0xbaddb3]\n"
-        "Trade::SceneData: object data [0xdead:0xdeb7] of field 0 are not contained in passed data array [0x0:0x0]\n"
+        "Trade::SceneData: mapping data [0xbaddaa:0xbaddb4] of field 0 are not contained in passed data array [0xbadda9:0xbaddb3]\n"
+        "Trade::SceneData: mapping data [0xdead:0xdeb7] of field 1 are not contained in passed data array [0xbadda9:0xbaddb3]\n"
+        "Trade::SceneData: mapping data [0xdead:0xdeb7] of field 1 are not contained in passed data array [0xbadda9:0xbaddb3]\n"
+        "Trade::SceneData: mapping data [0xdead:0xdeb7] of field 0 are not contained in passed data array [0x0:0x0]\n"
 
-        "Trade::SceneData: offset-only object data of field 0 span 25 bytes but passed data array has only 24\n");
+        "Trade::SceneData: offset-only mapping data of field 0 span 25 bytes but passed data array has only 24\n");
 }
 
 void SceneDataTest::constructFieldDataNotContained() {
@@ -1739,7 +1739,7 @@ void SceneDataTest::constructFieldDataNotContained() {
     CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
     #endif
 
-    /* Mostly the same as constructObjectDataNotContained() with object and
+    /* Mostly the same as constructMappingDataNotContained() with mapping and
        field views swapped, and added checks for array fields */
 
     Containers::Array<char> data{reinterpret_cast<char*>(0xbadda9), 10, [](char*, std::size_t){}};
@@ -1750,34 +1750,34 @@ void SceneDataTest::constructFieldDataNotContained() {
     std::ostringstream out;
     Error redirectError{&out};
     /* First a "slightly off" view that exceeds the original by one byte */
-    SceneData{SceneObjectType::UnsignedShort, 5, {}, data, {
+    SceneData{SceneMappingType::UnsignedShort, 5, {}, data, {
         SceneFieldData{SceneField::Mesh, dataIn, dataSlightlyOut}
     }};
     /* Second a view that's in a completely different location */
-    SceneData{SceneObjectType::UnsignedShort, 5, {}, data, {
+    SceneData{SceneMappingType::UnsignedShort, 5, {}, data, {
         SceneFieldData{SceneField::Light, dataIn, dataIn},
         SceneFieldData{SceneField::Mesh, dataIn, dataOut}
     }};
     /* Verify array size is taken into account as well. If not, the data would
        span only 7 bytes out of 10 (instead of 12), which is fine. */
-    SceneData{SceneObjectType::UnsignedShort, 5, {}, data, {
+    SceneData{SceneMappingType::UnsignedShort, 5, {}, data, {
         SceneFieldData{sceneFieldCustom(37), dataIn.prefix(2), Containers::StridedArrayView2D<UnsignedByte>{Containers::ArrayView<UnsignedByte>{reinterpret_cast<UnsignedByte*>(0xbadda9), 12}, {2, 6}}}
     }};
     /* Verify the owning constructor does the checks as well */
-    SceneData{SceneObjectType::UnsignedShort, 5, std::move(data), {
+    SceneData{SceneMappingType::UnsignedShort, 5, std::move(data), {
         SceneFieldData{SceneField::Light, dataIn, dataIn},
         SceneFieldData{SceneField::Mesh, dataIn, dataOut}
     }};
-    /* Not checking for nullptr data, since that got checked for object view
+    /* Not checking for nullptr data, since that got checked for mapping view
        already and there's no way to trigger it for fields */
     /* Finally, offset-only fields with a different message */
-    SceneData{SceneObjectType::UnsignedShort, 6, Containers::Array<char>{24}, {
-        SceneFieldData{SceneField::Mesh, 6, SceneObjectType::UnsignedShort, 0, 4, SceneFieldType::UnsignedByte, 4, 4}
+    SceneData{SceneMappingType::UnsignedShort, 6, Containers::Array<char>{24}, {
+        SceneFieldData{SceneField::Mesh, 6, SceneMappingType::UnsignedShort, 0, 4, SceneFieldType::UnsignedByte, 4, 4}
     }};
     /* This again spans 21 bytes if array size isn't taken into account, and 25
        if it is */
-    SceneData{SceneObjectType::UnsignedShort, 5, Containers::Array<char>{24}, {
-        SceneFieldData{sceneFieldCustom(37), 5, SceneObjectType::UnsignedShort, 0, 5, SceneFieldType::UnsignedByte, 0, 5, 5}
+    SceneData{SceneMappingType::UnsignedShort, 5, Containers::Array<char>{24}, {
+        SceneFieldData{sceneFieldCustom(37), 5, SceneMappingType::UnsignedShort, 0, 5, SceneFieldType::UnsignedByte, 0, 5, 5}
     }};
     CORRADE_COMPARE(out.str(),
         "Trade::SceneData: field data [0xbaddaa:0xbaddb4] of field 0 are not contained in passed data array [0xbadda9:0xbaddb3]\n"
@@ -1789,25 +1789,25 @@ void SceneDataTest::constructFieldDataNotContained() {
         "Trade::SceneData: offset-only field data of field 0 span 25 bytes but passed data array has only 24\n");
 }
 
-void SceneDataTest::constructObjectTypeTooSmall() {
+void SceneDataTest::constructMappingTypeTooSmall() {
     #ifdef CORRADE_NO_ASSERT
     CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
     #endif
 
     /* This is fine */
-    SceneData{SceneObjectType::UnsignedByte, 0xff, nullptr, {}};
-    SceneData{SceneObjectType::UnsignedShort, 0xffff, nullptr, {}};
-    SceneData{SceneObjectType::UnsignedInt, 0xffffffffu, nullptr, {}};
+    SceneData{SceneMappingType::UnsignedByte, 0xff, nullptr, {}};
+    SceneData{SceneMappingType::UnsignedShort, 0xffff, nullptr, {}};
+    SceneData{SceneMappingType::UnsignedInt, 0xffffffffu, nullptr, {}};
 
     std::ostringstream out;
     Error redirectError{&out};
-    SceneData{SceneObjectType::UnsignedByte, 0x100, nullptr, {}};
-    SceneData{SceneObjectType::UnsignedShort, 0x10000, nullptr, {}};
-    SceneData{SceneObjectType::UnsignedInt, 0x100000000ull, nullptr, {}};
+    SceneData{SceneMappingType::UnsignedByte, 0x100, nullptr, {}};
+    SceneData{SceneMappingType::UnsignedShort, 0x10000, nullptr, {}};
+    SceneData{SceneMappingType::UnsignedInt, 0x100000000ull, nullptr, {}};
     CORRADE_COMPARE(out.str(),
-        "Trade::SceneData: Trade::SceneObjectType::UnsignedByte is too small for 256 objects\n"
-        "Trade::SceneData: Trade::SceneObjectType::UnsignedShort is too small for 65536 objects\n"
-        "Trade::SceneData: Trade::SceneObjectType::UnsignedInt is too small for 4294967296 objects\n");
+        "Trade::SceneData: Trade::SceneMappingType::UnsignedByte is too small for 256 objects\n"
+        "Trade::SceneData: Trade::SceneMappingType::UnsignedShort is too small for 65536 objects\n"
+        "Trade::SceneData: Trade::SceneMappingType::UnsignedInt is too small for 4294967296 objects\n");
 }
 
 void SceneDataTest::constructNotOwnedFlagOwned() {
@@ -1819,7 +1819,7 @@ void SceneDataTest::constructNotOwnedFlagOwned() {
 
     std::ostringstream out;
     Error redirectError{&out};
-    SceneData{SceneObjectType::UnsignedByte, 5, DataFlag::Owned, Containers::arrayView(data), {}};
+    SceneData{SceneMappingType::UnsignedByte, 5, DataFlag::Owned, Containers::arrayView(data), {}};
     CORRADE_COMPARE(out.str(),
         "Trade::SceneData: can't construct with non-owned data but Trade::DataFlag::Owned\n");
 }
@@ -1832,41 +1832,41 @@ void SceneDataTest::constructMismatchedTRSViews() {
     Containers::ArrayView<const char> data{reinterpret_cast<char*>(0xcafe0000),
         /* Three entries, each having a 2D TRS and 3 object IDs */
         3*(24 + 12)};
-    Containers::ArrayView<const UnsignedInt> translationObjectData{
+    Containers::ArrayView<const UnsignedInt> translationMappingData{
         reinterpret_cast<const UnsignedInt*>(data.data()), 3};
     Containers::ArrayView<const Vector2> translationFieldData{
         reinterpret_cast<const Vector2*>(data.data() + 0x0c), 3};
-    Containers::ArrayView<const UnsignedInt> rotationObjectData{
+    Containers::ArrayView<const UnsignedInt> rotationMappingData{
         reinterpret_cast<const UnsignedInt*>(data.data() + 0x24), 3};
     Containers::ArrayView<const Complex> rotationFieldData{
         reinterpret_cast<const Complex*>(data.data() + 0x30), 3};
-    Containers::ArrayView<const UnsignedInt> scalingObjectData{
+    Containers::ArrayView<const UnsignedInt> scalingMappingData{
         reinterpret_cast<const UnsignedInt*>(data.data() + 0x48), 3};
     Containers::ArrayView<const Vector2> scalingFieldData{
         reinterpret_cast<const Vector2*>(data.data() + 0x54), 3};
 
-    SceneFieldData translations{SceneField::Translation, translationObjectData, translationFieldData};
-    SceneFieldData rotationsDifferent{SceneField::Rotation, rotationObjectData, rotationFieldData};
-    SceneFieldData scalingsDifferent{SceneField::Scaling, scalingObjectData, scalingFieldData};
-    SceneFieldData rotationsSameButLess{SceneField::Rotation, translationObjectData.except(1), rotationFieldData.except(1)};
-    SceneFieldData scalingsSameButLess{SceneField::Scaling, translationObjectData.except(2), scalingFieldData.except(2)};
+    SceneFieldData translations{SceneField::Translation, translationMappingData, translationFieldData};
+    SceneFieldData rotationsDifferent{SceneField::Rotation, rotationMappingData, rotationFieldData};
+    SceneFieldData scalingsDifferent{SceneField::Scaling, scalingMappingData, scalingFieldData};
+    SceneFieldData rotationsSameButLess{SceneField::Rotation, translationMappingData.except(1), rotationFieldData.except(1)};
+    SceneFieldData scalingsSameButLess{SceneField::Scaling, translationMappingData.except(2), scalingFieldData.except(2)};
 
     /* Test that all pairs get checked */
     std::ostringstream out;
     Error redirectError{&out};
-    SceneData{SceneObjectType::UnsignedInt, 3, {}, data, {translations, rotationsDifferent}};
-    SceneData{SceneObjectType::UnsignedInt, 3, {}, data, {translations, scalingsDifferent}};
-    SceneData{SceneObjectType::UnsignedInt, 3, {}, data, {rotationsDifferent, scalingsDifferent}};
-    SceneData{SceneObjectType::UnsignedInt, 3, {}, data, {translations, rotationsSameButLess}};
-    SceneData{SceneObjectType::UnsignedInt, 3, {}, data, {translations, scalingsSameButLess}};
-    SceneData{SceneObjectType::UnsignedInt, 3, {}, data, {rotationsSameButLess, scalingsSameButLess}};
+    SceneData{SceneMappingType::UnsignedInt, 3, {}, data, {translations, rotationsDifferent}};
+    SceneData{SceneMappingType::UnsignedInt, 3, {}, data, {translations, scalingsDifferent}};
+    SceneData{SceneMappingType::UnsignedInt, 3, {}, data, {rotationsDifferent, scalingsDifferent}};
+    SceneData{SceneMappingType::UnsignedInt, 3, {}, data, {translations, rotationsSameButLess}};
+    SceneData{SceneMappingType::UnsignedInt, 3, {}, data, {translations, scalingsSameButLess}};
+    SceneData{SceneMappingType::UnsignedInt, 3, {}, data, {rotationsSameButLess, scalingsSameButLess}};
     CORRADE_COMPARE(out.str(),
-        "Trade::SceneData: Trade::SceneField::Rotation object data [0xcafe0024:0xcafe0030] is different from Trade::SceneField::Translation object data [0xcafe0000:0xcafe000c]\n"
-        "Trade::SceneData: Trade::SceneField::Scaling object data [0xcafe0048:0xcafe0054] is different from Trade::SceneField::Translation object data [0xcafe0000:0xcafe000c]\n"
-        "Trade::SceneData: Trade::SceneField::Scaling object data [0xcafe0048:0xcafe0054] is different from Trade::SceneField::Rotation object data [0xcafe0024:0xcafe0030]\n"
-        "Trade::SceneData: Trade::SceneField::Rotation object data [0xcafe0000:0xcafe0008] is different from Trade::SceneField::Translation object data [0xcafe0000:0xcafe000c]\n"
-        "Trade::SceneData: Trade::SceneField::Scaling object data [0xcafe0000:0xcafe0004] is different from Trade::SceneField::Translation object data [0xcafe0000:0xcafe000c]\n"
-        "Trade::SceneData: Trade::SceneField::Scaling object data [0xcafe0000:0xcafe0004] is different from Trade::SceneField::Rotation object data [0xcafe0000:0xcafe0008]\n");
+        "Trade::SceneData: Trade::SceneField::Rotation mapping data [0xcafe0024:0xcafe0030] is different from Trade::SceneField::Translation mapping data [0xcafe0000:0xcafe000c]\n"
+        "Trade::SceneData: Trade::SceneField::Scaling mapping data [0xcafe0048:0xcafe0054] is different from Trade::SceneField::Translation mapping data [0xcafe0000:0xcafe000c]\n"
+        "Trade::SceneData: Trade::SceneField::Scaling mapping data [0xcafe0048:0xcafe0054] is different from Trade::SceneField::Rotation mapping data [0xcafe0024:0xcafe0030]\n"
+        "Trade::SceneData: Trade::SceneField::Rotation mapping data [0xcafe0000:0xcafe0008] is different from Trade::SceneField::Translation mapping data [0xcafe0000:0xcafe000c]\n"
+        "Trade::SceneData: Trade::SceneField::Scaling mapping data [0xcafe0000:0xcafe0004] is different from Trade::SceneField::Translation mapping data [0xcafe0000:0xcafe000c]\n"
+        "Trade::SceneData: Trade::SceneField::Scaling mapping data [0xcafe0000:0xcafe0004] is different from Trade::SceneField::Rotation mapping data [0xcafe0000:0xcafe0008]\n");
 }
 
 template<class> struct NameTraits;
@@ -1918,49 +1918,49 @@ template<class T> void SceneDataTest::constructMismatchedTRSDimensionality() {
     CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
     #endif
 
-    SceneFieldData transformationMatrices2D{SceneField::Transformation, SceneObjectType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Matrix3<T>>::type(), nullptr};
-    SceneFieldData transformationRectangularMatrices2D{SceneField::Transformation, SceneObjectType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Matrix3x2<T>>::type(), nullptr};
-    SceneFieldData transformations2D{SceneField::Transformation, SceneObjectType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::DualComplex<T>>::type(), nullptr};
-    SceneFieldData transformationMatrices3D{SceneField::Transformation, SceneObjectType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Matrix4<T>>::type(), nullptr};
-    SceneFieldData transformationRectangularMatrices3D{SceneField::Transformation, SceneObjectType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Matrix4x3<T>>::type(), nullptr};
-    SceneFieldData transformations3D{SceneField::Transformation, SceneObjectType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::DualQuaternion<T>>::type(), nullptr};
-    SceneFieldData translations2D{SceneField::Translation, SceneObjectType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Vector2<T>>::type(), nullptr};
-    SceneFieldData translations3D{SceneField::Translation, SceneObjectType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Vector3<T>>::type(), nullptr};
-    SceneFieldData rotations2D{SceneField::Rotation, SceneObjectType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Complex<T>>::type(), nullptr};
-    SceneFieldData rotations3D{SceneField::Rotation, SceneObjectType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Quaternion<T>>::type(), nullptr};
-    SceneFieldData scalings2D{SceneField::Scaling, SceneObjectType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Vector2<T>>::type(), nullptr};
-    SceneFieldData scalings3D{SceneField::Scaling, SceneObjectType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Vector3<T>>::type(), nullptr};
+    SceneFieldData transformationMatrices2D{SceneField::Transformation, SceneMappingType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Matrix3<T>>::type(), nullptr};
+    SceneFieldData transformationRectangularMatrices2D{SceneField::Transformation, SceneMappingType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Matrix3x2<T>>::type(), nullptr};
+    SceneFieldData transformations2D{SceneField::Transformation, SceneMappingType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::DualComplex<T>>::type(), nullptr};
+    SceneFieldData transformationMatrices3D{SceneField::Transformation, SceneMappingType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Matrix4<T>>::type(), nullptr};
+    SceneFieldData transformationRectangularMatrices3D{SceneField::Transformation, SceneMappingType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Matrix4x3<T>>::type(), nullptr};
+    SceneFieldData transformations3D{SceneField::Transformation, SceneMappingType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::DualQuaternion<T>>::type(), nullptr};
+    SceneFieldData translations2D{SceneField::Translation, SceneMappingType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Vector2<T>>::type(), nullptr};
+    SceneFieldData translations3D{SceneField::Translation, SceneMappingType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Vector3<T>>::type(), nullptr};
+    SceneFieldData rotations2D{SceneField::Rotation, SceneMappingType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Complex<T>>::type(), nullptr};
+    SceneFieldData rotations3D{SceneField::Rotation, SceneMappingType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Quaternion<T>>::type(), nullptr};
+    SceneFieldData scalings2D{SceneField::Scaling, SceneMappingType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Vector2<T>>::type(), nullptr};
+    SceneFieldData scalings3D{SceneField::Scaling, SceneMappingType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Vector3<T>>::type(), nullptr};
 
     /* Test that all pairs get checked */
     std::ostringstream out;
     Error redirectError{&out};
-    SceneData{SceneObjectType::UnsignedInt, 0, nullptr, {transformationMatrices2D, translations3D}};
-    SceneData{SceneObjectType::UnsignedInt, 0, nullptr, {transformationMatrices2D, rotations3D}};
-    SceneData{SceneObjectType::UnsignedInt, 0, nullptr, {transformationMatrices2D, scalings3D}};
-    SceneData{SceneObjectType::UnsignedInt, 0, nullptr, {transformationRectangularMatrices2D, translations3D}};
-    SceneData{SceneObjectType::UnsignedInt, 0, nullptr, {transformationRectangularMatrices2D, rotations3D}};
-    SceneData{SceneObjectType::UnsignedInt, 0, nullptr, {transformationRectangularMatrices2D, scalings3D}};
-
-    SceneData{SceneObjectType::UnsignedInt, 0, nullptr, {transformations2D, translations3D}};
-    SceneData{SceneObjectType::UnsignedInt, 0, nullptr, {transformations2D, rotations3D}};
-    SceneData{SceneObjectType::UnsignedInt, 0, nullptr, {transformations2D, scalings3D}};
-    SceneData{SceneObjectType::UnsignedInt, 0, nullptr, {translations2D, rotations3D}};
-    SceneData{SceneObjectType::UnsignedInt, 0, nullptr, {translations2D, scalings3D}};
-    SceneData{SceneObjectType::UnsignedInt, 0, nullptr, {rotations2D, scalings3D}};
-
-    SceneData{SceneObjectType::UnsignedInt, 0, nullptr, {transformationMatrices3D, translations2D}};
-    SceneData{SceneObjectType::UnsignedInt, 0, nullptr, {transformationMatrices3D, rotations2D}};
-    SceneData{SceneObjectType::UnsignedInt, 0, nullptr, {transformationMatrices3D, scalings2D}};
-    SceneData{SceneObjectType::UnsignedInt, 0, nullptr, {transformationRectangularMatrices3D, translations2D}};
-    SceneData{SceneObjectType::UnsignedInt, 0, nullptr, {transformationRectangularMatrices3D, rotations2D}};
-    SceneData{SceneObjectType::UnsignedInt, 0, nullptr, {transformationRectangularMatrices3D, scalings2D}};
-
-    SceneData{SceneObjectType::UnsignedInt, 0, nullptr, {transformations3D, translations2D}};
-    SceneData{SceneObjectType::UnsignedInt, 0, nullptr, {transformations3D, rotations2D}};
-    SceneData{SceneObjectType::UnsignedInt, 0, nullptr, {transformations3D, scalings2D}};
-    SceneData{SceneObjectType::UnsignedInt, 0, nullptr, {translations3D, rotations2D}};
-    SceneData{SceneObjectType::UnsignedInt, 0, nullptr, {translations3D, scalings2D}};
-    SceneData{SceneObjectType::UnsignedInt, 0, nullptr, {rotations3D, scalings2D}};
+    SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformationMatrices2D, translations3D}};
+    SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformationMatrices2D, rotations3D}};
+    SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformationMatrices2D, scalings3D}};
+    SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformationRectangularMatrices2D, translations3D}};
+    SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformationRectangularMatrices2D, rotations3D}};
+    SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformationRectangularMatrices2D, scalings3D}};
+
+    SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformations2D, translations3D}};
+    SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformations2D, rotations3D}};
+    SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformations2D, scalings3D}};
+    SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {translations2D, rotations3D}};
+    SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {translations2D, scalings3D}};
+    SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {rotations2D, scalings3D}};
+
+    SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformationMatrices3D, translations2D}};
+    SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformationMatrices3D, rotations2D}};
+    SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformationMatrices3D, scalings2D}};
+    SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformationRectangularMatrices3D, translations2D}};
+    SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformationRectangularMatrices3D, rotations2D}};
+    SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformationRectangularMatrices3D, scalings2D}};
+
+    SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformations3D, translations2D}};
+    SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformations3D, rotations2D}};
+    SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformations3D, scalings2D}};
+    SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {translations3D, rotations2D}};
+    SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {translations3D, scalings2D}};
+    SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {rotations3D, scalings2D}};
     CORRADE_COMPARE(out.str(), Utility::formatString(
         "Trade::SceneData: expected a 2D translation field but got Trade::SceneFieldType::{0}\n"
         "Trade::SceneData: expected a 2D rotation field but got Trade::SceneFieldType::{1}\n"
@@ -2003,26 +2003,26 @@ void SceneDataTest::constructMismatchedMeshMaterialView() {
     Containers::ArrayView<const char> data{reinterpret_cast<char*>(0xcafe0000),
         /* Three entries, each having mesh/material ID and 2 object IDs */
         3*(8 + 8)};
-    Containers::ArrayView<const UnsignedInt> meshObjectData{
+    Containers::ArrayView<const UnsignedInt> meshMappingData{
         reinterpret_cast<const UnsignedInt*>(data.data()), 3};
     Containers::ArrayView<const UnsignedInt> meshFieldData{
         reinterpret_cast<const UnsignedInt*>(data.data() + 0x0c), 3};
-    Containers::ArrayView<const UnsignedInt> meshMaterialObjectData{
+    Containers::ArrayView<const UnsignedInt> meshMaterialMappingData{
         reinterpret_cast<const UnsignedInt*>(data.data() + 0x18), 3};
     Containers::ArrayView<const Int> meshMaterialFieldData{
         reinterpret_cast<const Int*>(data.data() + 0x24), 3};
 
-    SceneFieldData meshes{SceneField::Mesh, meshObjectData, meshFieldData};
-    SceneFieldData meshMaterialsDifferent{SceneField::MeshMaterial, meshMaterialObjectData, meshMaterialFieldData};
-    SceneFieldData meshMaterialsSameButLess{SceneField::MeshMaterial, meshObjectData.except(1), meshMaterialFieldData.except(1)};
+    SceneFieldData meshes{SceneField::Mesh, meshMappingData, meshFieldData};
+    SceneFieldData meshMaterialsDifferent{SceneField::MeshMaterial, meshMaterialMappingData, meshMaterialFieldData};
+    SceneFieldData meshMaterialsSameButLess{SceneField::MeshMaterial, meshMappingData.except(1), meshMaterialFieldData.except(1)};
 
     std::ostringstream out;
     Error redirectError{&out};
-    SceneData{SceneObjectType::UnsignedInt, 3, {}, data, {meshes, meshMaterialsDifferent}};
-    SceneData{SceneObjectType::UnsignedInt, 3, {}, data, {meshes, meshMaterialsSameButLess}};
+    SceneData{SceneMappingType::UnsignedInt, 3, {}, data, {meshes, meshMaterialsDifferent}};
+    SceneData{SceneMappingType::UnsignedInt, 3, {}, data, {meshes, meshMaterialsSameButLess}};
     CORRADE_COMPARE(out.str(),
-        "Trade::SceneData: Trade::SceneField::MeshMaterial object data [0xcafe0018:0xcafe0024] is different from Trade::SceneField::Mesh object data [0xcafe0000:0xcafe000c]\n"
-        "Trade::SceneData: Trade::SceneField::MeshMaterial object data [0xcafe0000:0xcafe0008] is different from Trade::SceneField::Mesh object data [0xcafe0000:0xcafe000c]\n");
+        "Trade::SceneData: Trade::SceneField::MeshMaterial mapping data [0xcafe0018:0xcafe0024] is different from Trade::SceneField::Mesh mapping data [0xcafe0000:0xcafe000c]\n"
+        "Trade::SceneData: Trade::SceneField::MeshMaterial mapping data [0xcafe0000:0xcafe0008] is different from Trade::SceneField::Mesh mapping data [0xcafe0000:0xcafe000c]\n");
 }
 
 void SceneDataTest::constructAmbiguousSkinDimensions() {
@@ -2032,8 +2032,8 @@ void SceneDataTest::constructAmbiguousSkinDimensions() {
 
     std::ostringstream out;
     Error redirectError{&out};
-    SceneData{SceneObjectType::UnsignedInt, 0, nullptr, {
-        SceneFieldData{SceneField::Skin, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::UnsignedInt, nullptr}
+    SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {
+        SceneFieldData{SceneField::Skin, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::UnsignedInt, nullptr}
     }};
     CORRADE_COMPARE(out.str(), "Trade::SceneData: a skin field requires some transformation field to be present in order to disambiguate between 2D and 3D\n");
 }
@@ -2057,12 +2057,12 @@ void SceneDataTest::constructMove() {
 
     int importerState;
     SceneFieldData meshes{SceneField::Mesh, stridedArrayView(meshData).slice(&Mesh::object), stridedArrayView(meshData).slice(&Mesh::mesh)};
-    SceneData a{SceneObjectType::UnsignedShort, 15, std::move(data), {meshes}, &importerState};
+    SceneData a{SceneMappingType::UnsignedShort, 15, std::move(data), {meshes}, &importerState};
 
     SceneData b{std::move(a)};
     CORRADE_COMPARE(b.dataFlags(), DataFlag::Owned|DataFlag::Mutable);
-    CORRADE_COMPARE(b.objectCount(), 15);
-    CORRADE_COMPARE(b.objectType(), SceneObjectType::UnsignedShort);
+    CORRADE_COMPARE(b.mappingBound(), 15);
+    CORRADE_COMPARE(b.mappingType(), SceneMappingType::UnsignedShort);
     CORRADE_COMPARE(b.fieldCount(), 1);
     CORRADE_COMPARE(b.importerState(), &importerState);
     CORRADE_COMPARE(static_cast<const void*>(b.data()), meshData.data());
@@ -2070,14 +2070,14 @@ void SceneDataTest::constructMove() {
     CORRADE_COMPARE(b.fieldType(0), SceneFieldType::UnsignedInt);
     CORRADE_COMPARE(b.fieldSize(0), 3);
     CORRADE_COMPARE(b.fieldArraySize(0), 0);
-    CORRADE_COMPARE(b.objects<UnsignedShort>(0)[2], 122);
+    CORRADE_COMPARE(b.mapping<UnsignedShort>(0)[2], 122);
     CORRADE_COMPARE(b.field<UnsignedInt>(0)[2], 2);
 
-    SceneData c{SceneObjectType::UnsignedByte, 76, nullptr, {}};
+    SceneData c{SceneMappingType::UnsignedByte, 76, nullptr, {}};
     c = std::move(b);
     CORRADE_COMPARE(c.dataFlags(), DataFlag::Owned|DataFlag::Mutable);
-    CORRADE_COMPARE(c.objectCount(), 15);
-    CORRADE_COMPARE(c.objectType(), SceneObjectType::UnsignedShort);
+    CORRADE_COMPARE(c.mappingBound(), 15);
+    CORRADE_COMPARE(c.mappingType(), SceneMappingType::UnsignedShort);
     CORRADE_COMPARE(c.fieldCount(), 1);
     CORRADE_COMPARE(c.importerState(), &importerState);
     CORRADE_COMPARE(static_cast<const void*>(c.data()), meshData.data());
@@ -2085,7 +2085,7 @@ void SceneDataTest::constructMove() {
     CORRADE_COMPARE(c.fieldType(0), SceneFieldType::UnsignedInt);
     CORRADE_COMPARE(c.fieldSize(0), 3);
     CORRADE_COMPARE(c.fieldArraySize(0), 0);
-    CORRADE_COMPARE(c.objects<UnsignedShort>(0)[2], 122);
+    CORRADE_COMPARE(c.mapping<UnsignedShort>(0)[2], 122);
     CORRADE_COMPARE(c.field<UnsignedInt>(0)[2], 2);
 
     CORRADE_VERIFY(std::is_nothrow_move_constructible<SceneData>::value);
@@ -2093,9 +2093,9 @@ void SceneDataTest::constructMove() {
 }
 
 void SceneDataTest::findFieldId() {
-    SceneData scene{SceneObjectType::UnsignedInt, 0, {}, nullptr, {
-        SceneFieldData{SceneField::Parent, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
-        SceneFieldData{SceneField::Mesh, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::UnsignedByte, nullptr}
+    SceneData scene{SceneMappingType::UnsignedInt, 0, {}, nullptr, {
+        SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
+        SceneFieldData{SceneField::Mesh, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::UnsignedByte, nullptr}
     }};
 
     CORRADE_COMPARE(scene.findFieldId(SceneField::Parent), 0);
@@ -2127,9 +2127,9 @@ template<class T> void SceneDataTest::findFieldObjectOffset() {
     };
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{Implementation::sceneObjectTypeFor<T>(), 7, {}, fields, {
+    SceneData scene{Implementation::sceneMappingTypeFor<T>(), 7, {}, fields, {
         /* Test also with a completely empty field */
-        SceneFieldData{SceneField::Parent, Implementation::sceneObjectTypeFor<T>(), nullptr, SceneFieldType::Int, nullptr},
+        SceneFieldData{SceneField::Parent, Implementation::sceneMappingTypeFor<T>(), nullptr, SceneFieldType::Int, nullptr},
         SceneFieldData{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh)}
     }};
 
@@ -2184,7 +2184,7 @@ void SceneDataTest::findFieldObjectOffsetInvalidOffset() {
     };
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 7, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
         SceneFieldData{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh)}
     }};
 
@@ -2218,9 +2218,9 @@ void SceneDataTest::fieldObjectOffsetNotFound() {
     };
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 7, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
         /* Test also with a completely empty field */
-        SceneFieldData{SceneField::Parent, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
+        SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
         SceneFieldData{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh)}
     }};
 
@@ -2237,7 +2237,7 @@ void SceneDataTest::fieldObjectOffsetNotFound() {
         "Trade::SceneData::fieldObjectOffset(): object 1 not found in field Trade::SceneField::Mesh starting at offset 2\n");
 }
 
-template<class T> void SceneDataTest::objectsAsArrayByIndex() {
+template<class T> void SceneDataTest::mappingAsArrayByIndex() {
     setTestCaseTemplateName(NameTraits<T>::name());
 
     struct Field {
@@ -2251,18 +2251,18 @@ template<class T> void SceneDataTest::objectsAsArrayByIndex() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{Implementation::sceneObjectTypeFor<T>(), 50, {}, fields, {
+    SceneData scene{Implementation::sceneMappingTypeFor<T>(), 50, {}, fields, {
         /* To verify it isn't just picking the first ever field */
-        SceneFieldData{SceneField::Parent, Implementation::sceneObjectTypeFor<T>(), nullptr, SceneFieldType::Int, nullptr},
+        SceneFieldData{SceneField::Parent, Implementation::sceneMappingTypeFor<T>(), nullptr, SceneFieldType::Int, nullptr},
         SceneFieldData{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh)}
     }};
 
-    CORRADE_COMPARE_AS(scene.objectsAsArray(1),
+    CORRADE_COMPARE_AS(scene.mappingAsArray(1),
         Containers::arrayView<UnsignedInt>({15, 37, 44}),
         TestSuite::Compare::Container);
 }
 
-template<class T> void SceneDataTest::objectsAsArrayByName() {
+template<class T> void SceneDataTest::mappingAsArrayByName() {
     setTestCaseTemplateName(NameTraits<T>::name());
 
     struct Field {
@@ -2276,18 +2276,18 @@ template<class T> void SceneDataTest::objectsAsArrayByName() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{Implementation::sceneObjectTypeFor<T>(), 50, {}, fields, {
+    SceneData scene{Implementation::sceneMappingTypeFor<T>(), 50, {}, fields, {
         /* To verify it isn't just picking the first ever field */
-        SceneFieldData{SceneField::Parent, Implementation::sceneObjectTypeFor<T>(), nullptr, SceneFieldType::Int, nullptr},
+        SceneFieldData{SceneField::Parent, Implementation::sceneMappingTypeFor<T>(), nullptr, SceneFieldType::Int, nullptr},
         SceneFieldData{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh)}
     }};
 
-    CORRADE_COMPARE_AS(scene.objectsAsArray(SceneField::Mesh),
+    CORRADE_COMPARE_AS(scene.mappingAsArray(SceneField::Mesh),
         Containers::arrayView<UnsignedInt>({15, 37, 44}),
         TestSuite::Compare::Container);
 }
 
-void SceneDataTest::objectsIntoArrayByIndex() {
+void SceneDataTest::mappingIntoArrayByIndex() {
     auto&& data = IntoArrayOffsetData[testCaseInstanceId()];
     setTestCaseDescription(data.name);
 
@@ -2306,9 +2306,9 @@ void SceneDataTest::objectsIntoArrayByIndex() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 50, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 50, {}, fields, {
         /* To verify it isn't just picking the first ever field */
-        SceneFieldData{SceneField::Parent, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
+        SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
         SceneFieldData{SceneField::Mesh,
             view.slice(&Field::object),
             view.slice(&Field::mesh)},
@@ -2317,7 +2317,7 @@ void SceneDataTest::objectsIntoArrayByIndex() {
     /* The offset-less overload should give back all data */
     {
         UnsignedInt out[3];
-        scene.objectsInto(1, out);
+        scene.mappingInto(1, out);
         CORRADE_COMPARE_AS(Containers::stridedArrayView(out),
             view.slice(&Field::object),
             TestSuite::Compare::Container);
@@ -2325,7 +2325,7 @@ void SceneDataTest::objectsIntoArrayByIndex() {
     /* The offset variant only a subset */
     } {
         Containers::Array<UnsignedInt> out{data.size};
-        CORRADE_COMPARE(scene.objectsInto(1, data.offset, out), data.expectedSize);
+        CORRADE_COMPARE(scene.mappingInto(1, data.offset, out), data.expectedSize);
         CORRADE_COMPARE_AS(out.prefix(data.expectedSize),
             view.slice(&Field::object)
                 .slice(data.offset, data.offset + data.expectedSize),
@@ -2333,7 +2333,7 @@ void SceneDataTest::objectsIntoArrayByIndex() {
     }
 }
 
-void SceneDataTest::objectsIntoArrayByName() {
+void SceneDataTest::mappingIntoArrayByName() {
     auto&& data = IntoArrayOffsetData[testCaseInstanceId()];
     setTestCaseDescription(data.name);
 
@@ -2352,9 +2352,9 @@ void SceneDataTest::objectsIntoArrayByName() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 50, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 50, {}, fields, {
         /* To verify it isn't just picking the first ever field */
-        SceneFieldData{SceneField::Parent, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
+        SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
         SceneFieldData{SceneField::Mesh,
             view.slice(&Field::object),
             view.slice(&Field::mesh)},
@@ -2363,7 +2363,7 @@ void SceneDataTest::objectsIntoArrayByName() {
     /* The offset-less overload should give back all data */
     {
         UnsignedInt out[3];
-        scene.objectsInto(SceneField::Mesh, out);
+        scene.mappingInto(SceneField::Mesh, out);
         CORRADE_COMPARE_AS(Containers::stridedArrayView(out),
             view.slice(&Field::object),
             TestSuite::Compare::Container);
@@ -2371,7 +2371,7 @@ void SceneDataTest::objectsIntoArrayByName() {
     /* The offset variant only a subset */
     } {
         Containers::Array<UnsignedInt> out{data.size};
-        CORRADE_COMPARE(scene.objectsInto(SceneField::Mesh, data.offset, out), data.expectedSize);
+        CORRADE_COMPARE(scene.mappingInto(SceneField::Mesh, data.offset, out), data.expectedSize);
         CORRADE_COMPARE_AS(out.prefix(data.expectedSize),
             view.slice(&Field::object)
                 .slice(data.offset, data.offset + data.expectedSize),
@@ -2379,7 +2379,7 @@ void SceneDataTest::objectsIntoArrayByName() {
     }
 }
 
-void SceneDataTest::objectsIntoArrayInvalidSizeOrOffset() {
+void SceneDataTest::mappingIntoArrayInvalidSizeOrOffset() {
     #ifdef CORRADE_NO_ASSERT
     CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
     #endif
@@ -2391,22 +2391,22 @@ void SceneDataTest::objectsIntoArrayInvalidSizeOrOffset() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
         SceneFieldData{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh)}
     }};
 
     std::ostringstream out;
     Error redirectError{&out};
     UnsignedInt destination[2];
-    scene.objectsInto(0, destination);
-    scene.objectsInto(SceneField::Mesh, destination);
-    scene.objectsInto(0, 4, destination);
-    scene.objectsInto(SceneField::Mesh, 4, destination);
+    scene.mappingInto(0, destination);
+    scene.mappingInto(SceneField::Mesh, destination);
+    scene.mappingInto(0, 4, destination);
+    scene.mappingInto(SceneField::Mesh, 4, destination);
     CORRADE_COMPARE(out.str(),
-        "Trade::SceneData::objectsInto(): expected a view with 3 elements but got 2\n"
-        "Trade::SceneData::objectsInto(): expected a view with 3 elements but got 2\n"
-        "Trade::SceneData::objectsInto(): offset 4 out of bounds for a field of size 3\n"
-        "Trade::SceneData::objectsInto(): offset 4 out of bounds for a field of size 3\n");
+        "Trade::SceneData::mappingInto(): expected a view with 3 elements but got 2\n"
+        "Trade::SceneData::mappingInto(): expected a view with 3 elements but got 2\n"
+        "Trade::SceneData::mappingInto(): offset 4 out of bounds for a field of size 3\n"
+        "Trade::SceneData::mappingInto(): offset 4 out of bounds for a field of size 3\n");
 }
 
 template<class T> void SceneDataTest::parentsAsArray() {
@@ -2423,9 +2423,9 @@ template<class T> void SceneDataTest::parentsAsArray() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedByte, 50, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedByte, 50, {}, fields, {
         /* To verify it isn't just picking the first ever field */
-        SceneFieldData{SceneField::Mesh, SceneObjectType::UnsignedByte, nullptr, SceneFieldType::UnsignedInt, nullptr},
+        SceneFieldData{SceneField::Mesh, SceneMappingType::UnsignedByte, nullptr, SceneFieldType::UnsignedInt, nullptr},
         SceneFieldData{SceneField::Parent, view.slice(&Field::object), view.slice(&Field::parent)}
     }};
 
@@ -2455,9 +2455,9 @@ void SceneDataTest::parentsIntoArray() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
         /* To verify it isn't just picking the first ever field */
-        SceneFieldData{SceneField::Mesh, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::UnsignedInt, nullptr},
+        SceneFieldData{SceneField::Mesh, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::UnsignedInt, nullptr},
         SceneFieldData{SceneField::Parent,
             view.slice(&Field::object),
             view.slice(&Field::parent)},
@@ -2465,13 +2465,13 @@ void SceneDataTest::parentsIntoArray() {
 
     /* The offset-less overload should give back all data */
     {
-        UnsignedInt objects[3];
+        UnsignedInt mapping[3];
         Int field[3];
         scene.parentsInto(
-            data.objects ? Containers::arrayView(objects) : nullptr,
+            data.mapping ? Containers::arrayView(mapping) : nullptr,
             data.field ? Containers::arrayView(field) : nullptr
         );
-        if(data.objects) CORRADE_COMPARE_AS(Containers::stridedArrayView(objects),
+        if(data.mapping) CORRADE_COMPARE_AS(Containers::stridedArrayView(mapping),
             view.slice(&Field::object),
             TestSuite::Compare::Container);
         if(data.field) CORRADE_COMPARE_AS(Containers::stridedArrayView(field),
@@ -2480,13 +2480,13 @@ void SceneDataTest::parentsIntoArray() {
 
     /* The offset variant only a subset */
     } {
-        Containers::Array<UnsignedInt> objects{data.size};
+        Containers::Array<UnsignedInt> mapping{data.size};
         Containers::Array<Int> field{data.size};
         CORRADE_COMPARE(scene.parentsInto(data.offset,
-            data.objects ? arrayView(objects) : nullptr,
+            data.mapping ? arrayView(mapping) : nullptr,
             data.field ? arrayView(field) : nullptr
         ), data.expectedSize);
-        if(data.objects) CORRADE_COMPARE_AS(objects.prefix(data.expectedSize),
+        if(data.mapping) CORRADE_COMPARE_AS(mapping.prefix(data.expectedSize),
             view.slice(&Field::object)
                 .slice(data.offset, data.offset + data.expectedSize),
             TestSuite::Compare::Container);
@@ -2509,25 +2509,25 @@ void SceneDataTest::parentsIntoArrayInvalidSizeOrOffset() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
         SceneFieldData{SceneField::Parent, view.slice(&Field::object), view.slice(&Field::parent)}
     }};
 
     std::ostringstream out;
     Error redirectError{&out};
-    UnsignedInt objectDestinationCorrect[3];
-    UnsignedInt objectDestination[2];
+    UnsignedInt mappingDestinationCorrect[3];
+    UnsignedInt mappingDestination[2];
     Int fieldDestinationCorrect[3];
     Int fieldDestination[2];
-    scene.parentsInto(objectDestination, fieldDestinationCorrect);
-    scene.parentsInto(objectDestinationCorrect, fieldDestination);
-    scene.parentsInto(4, objectDestination, fieldDestination);
-    scene.parentsInto(0, objectDestinationCorrect, fieldDestination);
+    scene.parentsInto(mappingDestination, fieldDestinationCorrect);
+    scene.parentsInto(mappingDestinationCorrect, fieldDestination);
+    scene.parentsInto(4, mappingDestination, fieldDestination);
+    scene.parentsInto(0, mappingDestinationCorrect, fieldDestination);
     CORRADE_COMPARE(out.str(),
-        "Trade::SceneData::parentsInto(): expected object destination view either empty or with 3 elements but got 2\n"
+        "Trade::SceneData::parentsInto(): expected mapping destination view either empty or with 3 elements but got 2\n"
         "Trade::SceneData::parentsInto(): expected field destination view either empty or with 3 elements but got 2\n"
         "Trade::SceneData::parentsInto(): offset 4 out of bounds for a field of size 3\n"
-        "Trade::SceneData::parentsInto(): object and field destination views have different size, 3 vs 2\n");
+        "Trade::SceneData::parentsInto(): mapping and field destination views have different size, 3 vs 2\n");
 }
 
 template<class T> struct TransformationTypeFor {
@@ -2582,9 +2582,9 @@ template<class T> void SceneDataTest::transformations2DAsArray() {
        for those and error/warn on those, they get just ignored. */
     components[1] = {2, {3.5f, -1.0f}, {1.0f, 1.5f}};
 
-    SceneData scene{SceneObjectType::UnsignedInt, 6, std::move(data), {
+    SceneData scene{SceneMappingType::UnsignedInt, 6, std::move(data), {
         /* To verify it isn't just picking the first ever field */
-        SceneFieldData{SceneField::Parent, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
+        SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
         SceneFieldData{SceneField::Transformation,
             transformations.slice(&Transformation::object),
             transformations.slice(&Transformation::transformation)},
@@ -2646,7 +2646,7 @@ template<class T, class U, class V> void SceneDataTest::transformations2DAsArray
 
     /* Just one of translation / rotation / scaling */
     {
-        SceneData scene{SceneObjectType::UnsignedInt, 8, {}, fields, {
+        SceneData scene{SceneMappingType::UnsignedInt, 8, {}, fields, {
             translation
         }};
         CORRADE_VERIFY(scene.is2D());
@@ -2666,7 +2666,7 @@ template<class T, class U, class V> void SceneDataTest::transformations2DAsArray
             {7, {{1.5f, 2.5f}, {}, Vector2{1.0f}}},
         })), TestSuite::Compare::Container);
     } {
-        SceneData scene{SceneObjectType::UnsignedInt, 8, {}, fields, {
+        SceneData scene{SceneMappingType::UnsignedInt, 8, {}, fields, {
             rotation
         }};
         CORRADE_VERIFY(scene.is2D());
@@ -2686,7 +2686,7 @@ template<class T, class U, class V> void SceneDataTest::transformations2DAsArray
             {7, {{}, Complex::rotation(-15.0_degf), Vector2{1.0f}}},
         })), TestSuite::Compare::Container);
     } {
-        SceneData scene{SceneObjectType::UnsignedInt, 8, {}, fields, {
+        SceneData scene{SceneMappingType::UnsignedInt, 8, {}, fields, {
             scaling
         }};
         CORRADE_VERIFY(scene.is2D());
@@ -2709,7 +2709,7 @@ template<class T, class U, class V> void SceneDataTest::transformations2DAsArray
 
     /* Pairs */
     {
-        SceneData scene{SceneObjectType::UnsignedInt, 8, {}, fields, {
+        SceneData scene{SceneMappingType::UnsignedInt, 8, {}, fields, {
             translation,
             rotation
         }};
@@ -2730,7 +2730,7 @@ template<class T, class U, class V> void SceneDataTest::transformations2DAsArray
             {7, {{1.5f, 2.5f}, Complex::rotation(-15.0_degf), Vector2{1.0f}}},
         })), TestSuite::Compare::Container);
     } {
-        SceneData scene{SceneObjectType::UnsignedInt, 8, {}, fields, {
+        SceneData scene{SceneMappingType::UnsignedInt, 8, {}, fields, {
             translation,
             scaling
         }};
@@ -2751,7 +2751,7 @@ template<class T, class U, class V> void SceneDataTest::transformations2DAsArray
             {7, {{1.5f, 2.5f}, {}, {-0.5f, 4.0f}}},
         })), TestSuite::Compare::Container);
     } {
-        SceneData scene{SceneObjectType::UnsignedInt, 8, {}, fields, {
+        SceneData scene{SceneMappingType::UnsignedInt, 8, {}, fields, {
             rotation,
             scaling
         }};
@@ -2775,7 +2775,7 @@ template<class T, class U, class V> void SceneDataTest::transformations2DAsArray
 
     /* All */
     {
-        SceneData scene{SceneObjectType::UnsignedInt, 8, {}, fields, {
+        SceneData scene{SceneMappingType::UnsignedInt, 8, {}, fields, {
             translation,
             rotation,
             scaling
@@ -2809,8 +2809,8 @@ void SceneDataTest::transformations2DAsArrayBut3DType() {
        assertion for translations, as those are at offset 0, which would be
        interpreted as an empty view if there were no elements. Thus using
        rotations instead. */
-    SceneData scene{SceneObjectType::UnsignedInt, 0, nullptr, {
-        SceneFieldData{SceneField::Rotation, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Quaternion, nullptr}
+    SceneData scene{SceneMappingType::UnsignedInt, 0, nullptr, {
+        SceneFieldData{SceneField::Rotation, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Quaternion, nullptr}
     }};
 
     std::ostringstream out;
@@ -2841,9 +2841,9 @@ void SceneDataTest::transformations2DIntoArray() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
         /* To verify it isn't just picking the first ever field */
-        SceneFieldData{SceneField::Parent, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
+        SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
         SceneFieldData{SceneField::Transformation,
             view.slice(&Field::object),
             view.slice(&Field::transformation)},
@@ -2851,13 +2851,13 @@ void SceneDataTest::transformations2DIntoArray() {
 
     /* The offset-less overload should give back all data */
     {
-        UnsignedInt objects[3];
+        UnsignedInt mapping[3];
         Matrix3 field[3];
         scene.transformations2DInto(
-            data.objects ? Containers::arrayView(objects) : nullptr,
+            data.mapping ? Containers::arrayView(mapping) : nullptr,
             data.field ? Containers::arrayView(field) : nullptr
         );
-        if(data.objects) CORRADE_COMPARE_AS(Containers::stridedArrayView(objects),
+        if(data.mapping) CORRADE_COMPARE_AS(Containers::stridedArrayView(mapping),
             view.slice(&Field::object),
             TestSuite::Compare::Container);
         if(data.field) CORRADE_COMPARE_AS(Containers::stridedArrayView(field),
@@ -2866,13 +2866,13 @@ void SceneDataTest::transformations2DIntoArray() {
 
     /* The offset variant only a subset */
     } {
-        Containers::Array<UnsignedInt> objects{data.size};
+        Containers::Array<UnsignedInt> mapping{data.size};
         Containers::Array<Matrix3> field{data.size};
         CORRADE_COMPARE(scene.transformations2DInto(data.offset,
-            data.objects ? arrayView(objects) : nullptr,
+            data.mapping ? arrayView(mapping) : nullptr,
             data.field ? arrayView(field) : nullptr
         ), data.expectedSize);
-        if(data.objects) CORRADE_COMPARE_AS(objects.prefix(data.expectedSize),
+        if(data.mapping) CORRADE_COMPARE_AS(mapping.prefix(data.expectedSize),
             view.slice(&Field::object)
                 .slice(data.offset, data.offset + data.expectedSize),
             TestSuite::Compare::Container);
@@ -2903,9 +2903,9 @@ void SceneDataTest::transformations2DTRSIntoArray() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
         /* To verify it isn't just picking the first ever field */
-        SceneFieldData{SceneField::Parent, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
+        SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
         SceneFieldData{SceneField::Translation,
             view.slice(&Field::object),
             view.slice(&Field::translation)},
@@ -2925,13 +2925,13 @@ void SceneDataTest::transformations2DTRSIntoArray() {
 
     /* The offset-less overload should give back all data */
     {
-        UnsignedInt objects[3];
+        UnsignedInt mapping[3];
         Matrix3 field[3];
         scene.transformations2DInto(
-            data.objects ? Containers::arrayView(objects) : nullptr,
+            data.mapping ? Containers::arrayView(mapping) : nullptr,
             data.field ? Containers::arrayView(field) : nullptr
         );
-        if(data.objects) CORRADE_COMPARE_AS(Containers::stridedArrayView(objects),
+        if(data.mapping) CORRADE_COMPARE_AS(Containers::stridedArrayView(mapping),
             view.slice(&Field::object),
             TestSuite::Compare::Container);
         if(data.field) CORRADE_COMPARE_AS(Containers::stridedArrayView(field),
@@ -2940,13 +2940,13 @@ void SceneDataTest::transformations2DTRSIntoArray() {
 
     /* The offset variant only a subset */
     } {
-        Containers::Array<UnsignedInt> objects{data.size};
+        Containers::Array<UnsignedInt> mapping{data.size};
         Containers::Array<Matrix3> field{data.size};
         CORRADE_COMPARE(scene.transformations2DInto(data.offset,
-            data.objects ? arrayView(objects) : nullptr,
+            data.mapping ? arrayView(mapping) : nullptr,
             data.field ? arrayView(field) : nullptr
         ), data.expectedSize);
-        if(data.objects) CORRADE_COMPARE_AS(objects.prefix(data.expectedSize),
+        if(data.mapping) CORRADE_COMPARE_AS(mapping.prefix(data.expectedSize),
             view.slice(&Field::object)
                 .slice(data.offset, data.offset + data.expectedSize),
             TestSuite::Compare::Container);
@@ -2977,9 +2977,9 @@ void SceneDataTest::transformations2DIntoArrayTRS() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
         /* To verify it isn't just picking the first ever field */
-        SceneFieldData{SceneField::Parent, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
+        SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
         SceneFieldData{SceneField::Translation,
             view.slice(&Field::object),
             view.slice(&Field::translation)},
@@ -2993,17 +2993,17 @@ void SceneDataTest::transformations2DIntoArrayTRS() {
 
     /* The offset-less overload should give back all data */
     {
-        UnsignedInt objects[3];
+        UnsignedInt mapping[3];
         Vector2 translations[3];
         Complex rotations[3];
         Vector2 scalings[3];
         scene.translationsRotationsScalings2DInto(
-            data.objects ? Containers::arrayView(objects) : nullptr,
+            data.mapping ? Containers::arrayView(mapping) : nullptr,
             data.field1 ? Containers::arrayView(translations) : nullptr,
             data.field2 ? Containers::arrayView(rotations) : nullptr,
             data.field3 ? Containers::arrayView(scalings) : nullptr
         );
-        if(data.objects) CORRADE_COMPARE_AS(Containers::stridedArrayView(objects),
+        if(data.mapping) CORRADE_COMPARE_AS(Containers::stridedArrayView(mapping),
             view.slice(&Field::object),
             TestSuite::Compare::Container);
         if(data.field1) CORRADE_COMPARE_AS(Containers::stridedArrayView(translations),
@@ -3018,17 +3018,17 @@ void SceneDataTest::transformations2DIntoArrayTRS() {
 
     /* The offset variant only a subset */
     } {
-        Containers::Array<UnsignedInt> objects{data.size};
+        Containers::Array<UnsignedInt> mapping{data.size};
         Containers::Array<Vector2> translations{data.size};
         Containers::Array<Complex> rotations{data.size};
         Containers::Array<Vector2> scalings{data.size};
         CORRADE_COMPARE(scene.translationsRotationsScalings2DInto(data.offset,
-            data.objects ? arrayView(objects) : nullptr,
+            data.mapping ? arrayView(mapping) : nullptr,
             data.field1 ? arrayView(translations) : nullptr,
             data.field2 ? arrayView(rotations) : nullptr,
             data.field3 ? arrayView(scalings) : nullptr
         ), data.expectedSize);
-        if(data.objects) CORRADE_COMPARE_AS(objects.prefix(data.expectedSize),
+        if(data.mapping) CORRADE_COMPARE_AS(mapping.prefix(data.expectedSize),
             view.slice(&Field::object)
                 .slice(data.offset, data.offset + data.expectedSize),
             TestSuite::Compare::Container);
@@ -3059,25 +3059,25 @@ void SceneDataTest::transformations2DIntoArrayInvalidSizeOrOffset() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
         SceneFieldData{SceneField::Transformation, view.slice(&Field::object), view.slice(&Field::transformation)}
     }};
 
     std::ostringstream out;
     Error redirectError{&out};
-    UnsignedInt objectDestinationCorrect[3];
-    UnsignedInt objectDestination[2];
+    UnsignedInt mappingDestinationCorrect[3];
+    UnsignedInt mappingDestination[2];
     Matrix3 fieldDestinationCorrect[3];
     Matrix3 fieldDestination[2];
-    scene.transformations2DInto(objectDestination, fieldDestinationCorrect);
-    scene.transformations2DInto(objectDestinationCorrect, fieldDestination);
-    scene.transformations2DInto(4, objectDestination, fieldDestination);
-    scene.transformations2DInto(0, objectDestinationCorrect, fieldDestination);
+    scene.transformations2DInto(mappingDestination, fieldDestinationCorrect);
+    scene.transformations2DInto(mappingDestinationCorrect, fieldDestination);
+    scene.transformations2DInto(4, mappingDestination, fieldDestination);
+    scene.transformations2DInto(0, mappingDestinationCorrect, fieldDestination);
     CORRADE_COMPARE(out.str(),
-        "Trade::SceneData::transformations2DInto(): expected object destination view either empty or with 3 elements but got 2\n"
+        "Trade::SceneData::transformations2DInto(): expected mapping destination view either empty or with 3 elements but got 2\n"
         "Trade::SceneData::transformations2DInto(): expected field destination view either empty or with 3 elements but got 2\n"
         "Trade::SceneData::transformations2DInto(): offset 4 out of bounds for a field of size 3\n"
-        "Trade::SceneData::transformations2DInto(): object and field destination views have different size, 3 vs 2\n");
+        "Trade::SceneData::transformations2DInto(): mapping and field destination views have different size, 3 vs 2\n");
 }
 
 void SceneDataTest::transformations2DIntoArrayInvalidSizeOrOffsetTRS() {
@@ -3092,40 +3092,40 @@ void SceneDataTest::transformations2DIntoArrayInvalidSizeOrOffsetTRS() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
         SceneFieldData{SceneField::Translation, view.slice(&Field::object), view.slice(&Field::translation)}
     }};
 
     std::ostringstream out;
     Error redirectError{&out};
-    UnsignedInt objectDestinationCorrect[3];
-    UnsignedInt objectDestination[2];
+    UnsignedInt mappingDestinationCorrect[3];
+    UnsignedInt mappingDestination[2];
     Vector2 translationDestinationCorrect[3];
     Vector2 translationDestination[2];
     Complex rotationDestinationCorrect[3];
     Complex rotationDestination[2];
     Vector2 scalingDestinationCorrect[3];
     Vector2 scalingDestination[2];
-    scene.translationsRotationsScalings2DInto(objectDestination, translationDestinationCorrect, rotationDestinationCorrect, scalingDestinationCorrect);
-    scene.translationsRotationsScalings2DInto(objectDestinationCorrect, translationDestination, rotationDestinationCorrect, scalingDestinationCorrect);
-    scene.translationsRotationsScalings2DInto(objectDestinationCorrect, translationDestinationCorrect, rotationDestination, scalingDestinationCorrect);
-    scene.translationsRotationsScalings2DInto(objectDestinationCorrect, translationDestinationCorrect, rotationDestinationCorrect, scalingDestination);
-    scene.translationsRotationsScalings2DInto(4, objectDestination, translationDestination, rotationDestination, scalingDestination);
-    scene.translationsRotationsScalings2DInto(0, objectDestinationCorrect, translationDestination, nullptr, nullptr);
-    scene.translationsRotationsScalings2DInto(0, objectDestinationCorrect, nullptr, rotationDestination, nullptr);
-    scene.translationsRotationsScalings2DInto(0, objectDestinationCorrect, nullptr, nullptr, scalingDestination);
+    scene.translationsRotationsScalings2DInto(mappingDestination, translationDestinationCorrect, rotationDestinationCorrect, scalingDestinationCorrect);
+    scene.translationsRotationsScalings2DInto(mappingDestinationCorrect, translationDestination, rotationDestinationCorrect, scalingDestinationCorrect);
+    scene.translationsRotationsScalings2DInto(mappingDestinationCorrect, translationDestinationCorrect, rotationDestination, scalingDestinationCorrect);
+    scene.translationsRotationsScalings2DInto(mappingDestinationCorrect, translationDestinationCorrect, rotationDestinationCorrect, scalingDestination);
+    scene.translationsRotationsScalings2DInto(4, mappingDestination, translationDestination, rotationDestination, scalingDestination);
+    scene.translationsRotationsScalings2DInto(0, mappingDestinationCorrect, translationDestination, nullptr, nullptr);
+    scene.translationsRotationsScalings2DInto(0, mappingDestinationCorrect, nullptr, rotationDestination, nullptr);
+    scene.translationsRotationsScalings2DInto(0, mappingDestinationCorrect, nullptr, nullptr, scalingDestination);
     scene.translationsRotationsScalings2DInto(0, nullptr, translationDestinationCorrect, rotationDestination, nullptr);
     scene.translationsRotationsScalings2DInto(0, nullptr, translationDestinationCorrect, nullptr, scalingDestination);
     scene.translationsRotationsScalings2DInto(0, nullptr, nullptr, rotationDestinationCorrect, scalingDestination);
     CORRADE_COMPARE(out.str(),
-        "Trade::SceneData::translationsRotationsScalings2DInto(): expected object destination view either empty or with 3 elements but got 2\n"
+        "Trade::SceneData::translationsRotationsScalings2DInto(): expected mapping destination view either empty or with 3 elements but got 2\n"
         "Trade::SceneData::translationsRotationsScalings2DInto(): expected translation destination view either empty or with 3 elements but got 2\n"
         "Trade::SceneData::translationsRotationsScalings2DInto(): expected rotation destination view either empty or with 3 elements but got 2\n"
         "Trade::SceneData::translationsRotationsScalings2DInto(): expected scaling destination view either empty or with 3 elements but got 2\n"
         "Trade::SceneData::translationsRotationsScalings2DInto(): offset 4 out of bounds for a field of size 3\n"
-        "Trade::SceneData::translationsRotationsScalings2DInto(): object and translation destination views have different size, 3 vs 2\n"
-        "Trade::SceneData::translationsRotationsScalings2DInto(): object and rotation destination views have different size, 3 vs 2\n"
-        "Trade::SceneData::translationsRotationsScalings2DInto(): object and scaling destination views have different size, 3 vs 2\n"
+        "Trade::SceneData::translationsRotationsScalings2DInto(): mapping and translation destination views have different size, 3 vs 2\n"
+        "Trade::SceneData::translationsRotationsScalings2DInto(): mapping and rotation destination views have different size, 3 vs 2\n"
+        "Trade::SceneData::translationsRotationsScalings2DInto(): mapping and scaling destination views have different size, 3 vs 2\n"
         "Trade::SceneData::translationsRotationsScalings2DInto(): translation and rotation destination views have different size, 3 vs 2\n"
         "Trade::SceneData::translationsRotationsScalings2DInto(): translation and scaling destination views have different size, 3 vs 2\n"
         "Trade::SceneData::translationsRotationsScalings2DInto(): rotation and scaling destination views have different size, 3 vs 2\n");
@@ -3176,9 +3176,9 @@ template<class T> void SceneDataTest::transformations3DAsArray() {
        for those and error/warn on those, they get just ignored. */
     components[1] = {2, {3.5f, -1.0f, 2.2f}, {1.0f, 1.5f, 1.0f}};
 
-    SceneData scene{SceneObjectType::UnsignedInt, 6, std::move(data), {
+    SceneData scene{SceneMappingType::UnsignedInt, 6, std::move(data), {
         /* To verify it isn't just picking the first ever field */
-        SceneFieldData{SceneField::Parent, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
+        SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
         SceneFieldData{SceneField::Transformation,
             transformations.slice(&Transformation::object),
             transformations.slice(&Transformation::transformation)},
@@ -3240,7 +3240,7 @@ template<class T, class U, class V> void SceneDataTest::transformations3DAsArray
 
     /* Just one of translation / rotation / scaling */
     {
-        SceneData scene{SceneObjectType::UnsignedInt, 8, {}, fields, {
+        SceneData scene{SceneMappingType::UnsignedInt, 8, {}, fields, {
             translation
         }};
         CORRADE_VERIFY(!scene.is2D());
@@ -3260,7 +3260,7 @@ template<class T, class U, class V> void SceneDataTest::transformations3DAsArray
             {7, {{1.5f, 2.5f, 3.5f}, {}, Vector3{1.0f}}},
         })), TestSuite::Compare::Container);
     } {
-        SceneData scene{SceneObjectType::UnsignedInt, 8, {}, fields, {
+        SceneData scene{SceneMappingType::UnsignedInt, 8, {}, fields, {
             rotation
         }};
         CORRADE_VERIFY(!scene.is2D());
@@ -3280,7 +3280,7 @@ template<class T, class U, class V> void SceneDataTest::transformations3DAsArray
             {7, {{}, Quaternion::rotation(-15.0_degf, Vector3::xAxis()), Vector3{1.0f}}},
         })), TestSuite::Compare::Container);
     } {
-        SceneData scene{SceneObjectType::UnsignedInt, 8, {}, fields, {
+        SceneData scene{SceneMappingType::UnsignedInt, 8, {}, fields, {
             scaling
         }};
         CORRADE_VERIFY(!scene.is2D());
@@ -3303,7 +3303,7 @@ template<class T, class U, class V> void SceneDataTest::transformations3DAsArray
 
     /* Pairs */
     {
-        SceneData scene{SceneObjectType::UnsignedInt, 8, {}, fields, {
+        SceneData scene{SceneMappingType::UnsignedInt, 8, {}, fields, {
             translation,
             rotation
         }};
@@ -3324,7 +3324,7 @@ template<class T, class U, class V> void SceneDataTest::transformations3DAsArray
             {7, {{1.5f, 2.5f, 3.5f}, Quaternion::rotation(-15.0_degf, Vector3::xAxis()), Vector3{1.0f}}},
         })), TestSuite::Compare::Container);
     } {
-        SceneData scene{SceneObjectType::UnsignedInt, 8, {}, fields, {
+        SceneData scene{SceneMappingType::UnsignedInt, 8, {}, fields, {
             translation,
             scaling
         }};
@@ -3345,7 +3345,7 @@ template<class T, class U, class V> void SceneDataTest::transformations3DAsArray
             {7, {{1.5f, 2.5f, 3.5f}, {}, {-0.5f, 4.0f, -16.0f}}},
         })), TestSuite::Compare::Container);
     } {
-        SceneData scene{SceneObjectType::UnsignedInt, 8, {}, fields, {
+        SceneData scene{SceneMappingType::UnsignedInt, 8, {}, fields, {
             rotation,
             scaling
         }};
@@ -3369,7 +3369,7 @@ template<class T, class U, class V> void SceneDataTest::transformations3DAsArray
 
     /* All */
     {
-        SceneData scene{SceneObjectType::UnsignedInt, 8, {}, fields, {
+        SceneData scene{SceneMappingType::UnsignedInt, 8, {}, fields, {
             translation,
             rotation,
             scaling
@@ -3403,8 +3403,8 @@ void SceneDataTest::transformations3DAsArrayBut2DType() {
        assertion for translations, as those are at offset 0, which would be
        interpreted as an empty view if there were no elements. Thus using
        rotations instead. */
-    SceneData scene{SceneObjectType::UnsignedInt, 0, nullptr, {
-        SceneFieldData{SceneField::Rotation, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Complex, nullptr}
+    SceneData scene{SceneMappingType::UnsignedInt, 0, nullptr, {
+        SceneFieldData{SceneField::Rotation, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Complex, nullptr}
     }};
 
     std::ostringstream out;
@@ -3435,9 +3435,9 @@ void SceneDataTest::transformations3DIntoArray() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
         /* To verify it isn't just picking the first ever field */
-        SceneFieldData{SceneField::Parent, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
+        SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
         SceneFieldData{SceneField::Transformation,
             view.slice(&Field::object),
             view.slice(&Field::transformation)},
@@ -3445,13 +3445,13 @@ void SceneDataTest::transformations3DIntoArray() {
 
     /* The offset-less overload should give back all data */
     {
-        UnsignedInt objects[3];
+        UnsignedInt mapping[3];
         Matrix4 field[3];
         scene.transformations3DInto(
-            data.objects ? Containers::arrayView(objects) : nullptr,
+            data.mapping ? Containers::arrayView(mapping) : nullptr,
             data.field ? Containers::arrayView(field) : nullptr
         );
-        if(data.objects) CORRADE_COMPARE_AS(Containers::stridedArrayView(objects),
+        if(data.mapping) CORRADE_COMPARE_AS(Containers::stridedArrayView(mapping),
             view.slice(&Field::object),
             TestSuite::Compare::Container);
         if(data.field) CORRADE_COMPARE_AS(Containers::stridedArrayView(field),
@@ -3460,13 +3460,13 @@ void SceneDataTest::transformations3DIntoArray() {
 
     /* The offset variant only a subset */
     } {
-        Containers::Array<UnsignedInt> objects{data.size};
+        Containers::Array<UnsignedInt> mapping{data.size};
         Containers::Array<Matrix4> field{data.size};
         CORRADE_COMPARE(scene.transformations3DInto(data.offset,
-            data.objects ? arrayView(objects) : nullptr,
+            data.mapping ? arrayView(mapping) : nullptr,
             data.field ? arrayView(field) : nullptr
         ), data.expectedSize);
-        if(data.objects) CORRADE_COMPARE_AS(objects.prefix(data.expectedSize),
+        if(data.mapping) CORRADE_COMPARE_AS(mapping.prefix(data.expectedSize),
             view.slice(&Field::object)
                 .slice(data.offset, data.offset + data.expectedSize),
             TestSuite::Compare::Container);
@@ -3497,9 +3497,9 @@ void SceneDataTest::transformations3DTRSIntoArray() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
         /* To verify it isn't just picking the first ever field */
-        SceneFieldData{SceneField::Parent, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
+        SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
         SceneFieldData{SceneField::Translation,
             view.slice(&Field::object),
             view.slice(&Field::translation)},
@@ -3519,13 +3519,13 @@ void SceneDataTest::transformations3DTRSIntoArray() {
 
     /* The offset-less overload should give back all data */
     {
-        UnsignedInt objects[3];
+        UnsignedInt mapping[3];
         Matrix4 field[3];
         scene.transformations3DInto(
-            data.objects ? Containers::arrayView(objects) : nullptr,
+            data.mapping ? Containers::arrayView(mapping) : nullptr,
             data.field ? Containers::arrayView(field) : nullptr
         );
-        if(data.objects) CORRADE_COMPARE_AS(Containers::stridedArrayView(objects),
+        if(data.mapping) CORRADE_COMPARE_AS(Containers::stridedArrayView(mapping),
             view.slice(&Field::object),
             TestSuite::Compare::Container);
         if(data.field) CORRADE_COMPARE_AS(Containers::stridedArrayView(field),
@@ -3534,13 +3534,13 @@ void SceneDataTest::transformations3DTRSIntoArray() {
 
     /* The offset variant only a subset */
     } {
-        Containers::Array<UnsignedInt> objects{data.size};
+        Containers::Array<UnsignedInt> mapping{data.size};
         Containers::Array<Matrix4> field{data.size};
         CORRADE_COMPARE(scene.transformations3DInto(data.offset,
-            data.objects ? arrayView(objects) : nullptr,
+            data.mapping ? arrayView(mapping) : nullptr,
             data.field ? arrayView(field) : nullptr
         ), data.expectedSize);
-        if(data.objects) CORRADE_COMPARE_AS(objects.prefix(data.expectedSize),
+        if(data.mapping) CORRADE_COMPARE_AS(mapping.prefix(data.expectedSize),
             view.slice(&Field::object)
                 .slice(data.offset, data.offset + data.expectedSize),
             TestSuite::Compare::Container);
@@ -3571,9 +3571,9 @@ void SceneDataTest::transformations3DIntoArrayTRS() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
         /* To verify it isn't just picking the first ever field */
-        SceneFieldData{SceneField::Parent, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
+        SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
         SceneFieldData{SceneField::Translation,
             view.slice(&Field::object),
             view.slice(&Field::translation)},
@@ -3587,17 +3587,17 @@ void SceneDataTest::transformations3DIntoArrayTRS() {
 
     /* The offset-less overload should give back all data */
     {
-        UnsignedInt objects[3];
+        UnsignedInt mapping[3];
         Vector3 translations[3];
         Quaternion rotations[3];
         Vector3 scalings[3];
         scene.translationsRotationsScalings3DInto(
-            data.objects ? Containers::arrayView(objects) : nullptr,
+            data.mapping ? Containers::arrayView(mapping) : nullptr,
             data.field1 ? Containers::arrayView(translations) : nullptr,
             data.field2 ? Containers::arrayView(rotations) : nullptr,
             data.field3 ? Containers::arrayView(scalings) : nullptr
         );
-        if(data.objects) CORRADE_COMPARE_AS(Containers::stridedArrayView(objects),
+        if(data.mapping) CORRADE_COMPARE_AS(Containers::stridedArrayView(mapping),
             view.slice(&Field::object),
             TestSuite::Compare::Container);
         if(data.field1) CORRADE_COMPARE_AS(Containers::stridedArrayView(translations),
@@ -3612,17 +3612,17 @@ void SceneDataTest::transformations3DIntoArrayTRS() {
 
     /* The offset variant only a subset */
     } {
-        Containers::Array<UnsignedInt> objects{data.size};
+        Containers::Array<UnsignedInt> mapping{data.size};
         Containers::Array<Vector3> translations{data.size};
         Containers::Array<Quaternion> rotations{data.size};
         Containers::Array<Vector3> scalings{data.size};
         CORRADE_COMPARE(scene.translationsRotationsScalings3DInto(data.offset,
-            data.objects ? arrayView(objects) : nullptr,
+            data.mapping ? arrayView(mapping) : nullptr,
             data.field1 ? arrayView(translations) : nullptr,
             data.field2 ? arrayView(rotations) : nullptr,
             data.field3 ? arrayView(scalings) : nullptr
         ), data.expectedSize);
-        if(data.objects) CORRADE_COMPARE_AS(objects.prefix(data.expectedSize),
+        if(data.mapping) CORRADE_COMPARE_AS(mapping.prefix(data.expectedSize),
             view.slice(&Field::object)
                 .slice(data.offset, data.offset + data.expectedSize),
             TestSuite::Compare::Container);
@@ -3653,25 +3653,25 @@ void SceneDataTest::transformations3DIntoArrayInvalidSizeOrOffset() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
         SceneFieldData{SceneField::Transformation, view.slice(&Field::object), view.slice(&Field::transformation)}
     }};
 
     std::ostringstream out;
     Error redirectError{&out};
-    UnsignedInt objectDestinationCorrect[3];
-    UnsignedInt objectDestination[2];
+    UnsignedInt mappingDestinationCorrect[3];
+    UnsignedInt mappingDestination[2];
     Matrix4 fieldDestinationCorrect[3];
     Matrix4 fieldDestination[2];
-    scene.transformations3DInto(objectDestination, fieldDestinationCorrect);
-    scene.transformations3DInto(objectDestinationCorrect, fieldDestination);
-    scene.transformations3DInto(4, objectDestination, fieldDestination);
-    scene.transformations3DInto(0, objectDestinationCorrect, fieldDestination);
+    scene.transformations3DInto(mappingDestination, fieldDestinationCorrect);
+    scene.transformations3DInto(mappingDestinationCorrect, fieldDestination);
+    scene.transformations3DInto(4, mappingDestination, fieldDestination);
+    scene.transformations3DInto(0, mappingDestinationCorrect, fieldDestination);
     CORRADE_COMPARE(out.str(),
-        "Trade::SceneData::transformations3DInto(): expected object destination view either empty or with 3 elements but got 2\n"
+        "Trade::SceneData::transformations3DInto(): expected mapping destination view either empty or with 3 elements but got 2\n"
         "Trade::SceneData::transformations3DInto(): expected field destination view either empty or with 3 elements but got 2\n"
         "Trade::SceneData::transformations3DInto(): offset 4 out of bounds for a field of size 3\n"
-        "Trade::SceneData::transformations3DInto(): object and field destination views have different size, 3 vs 2\n");
+        "Trade::SceneData::transformations3DInto(): mapping and field destination views have different size, 3 vs 2\n");
 }
 
 void SceneDataTest::transformations3DIntoArrayInvalidSizeOrOffsetTRS() {
@@ -3686,40 +3686,40 @@ void SceneDataTest::transformations3DIntoArrayInvalidSizeOrOffsetTRS() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
         SceneFieldData{SceneField::Translation, view.slice(&Field::object), view.slice(&Field::translation)}
     }};
 
     std::ostringstream out;
     Error redirectError{&out};
-    UnsignedInt objectDestinationCorrect[3];
-    UnsignedInt objectDestination[2];
+    UnsignedInt mappingDestinationCorrect[3];
+    UnsignedInt mappingDestination[2];
     Vector3 translationDestinationCorrect[3];
     Vector3 translationDestination[2];
     Quaternion rotationDestinationCorrect[3];
     Quaternion rotationDestination[2];
     Vector3 scalingDestinationCorrect[3];
     Vector3 scalingDestination[2];
-    scene.translationsRotationsScalings3DInto(objectDestination, translationDestinationCorrect, rotationDestinationCorrect, scalingDestinationCorrect);
-    scene.translationsRotationsScalings3DInto(objectDestinationCorrect, translationDestination, rotationDestinationCorrect, scalingDestinationCorrect);
-    scene.translationsRotationsScalings3DInto(objectDestinationCorrect, translationDestinationCorrect, rotationDestination, scalingDestinationCorrect);
-    scene.translationsRotationsScalings3DInto(objectDestinationCorrect, translationDestinationCorrect, rotationDestinationCorrect, scalingDestination);
-    scene.translationsRotationsScalings3DInto(4, objectDestination, translationDestination, rotationDestination, scalingDestination);
-    scene.translationsRotationsScalings3DInto(0, objectDestinationCorrect, translationDestination, nullptr, nullptr);
-    scene.translationsRotationsScalings3DInto(0, objectDestinationCorrect, nullptr, rotationDestination, nullptr);
-    scene.translationsRotationsScalings3DInto(0, objectDestinationCorrect, nullptr, nullptr, scalingDestination);
+    scene.translationsRotationsScalings3DInto(mappingDestination, translationDestinationCorrect, rotationDestinationCorrect, scalingDestinationCorrect);
+    scene.translationsRotationsScalings3DInto(mappingDestinationCorrect, translationDestination, rotationDestinationCorrect, scalingDestinationCorrect);
+    scene.translationsRotationsScalings3DInto(mappingDestinationCorrect, translationDestinationCorrect, rotationDestination, scalingDestinationCorrect);
+    scene.translationsRotationsScalings3DInto(mappingDestinationCorrect, translationDestinationCorrect, rotationDestinationCorrect, scalingDestination);
+    scene.translationsRotationsScalings3DInto(4, mappingDestination, translationDestination, rotationDestination, scalingDestination);
+    scene.translationsRotationsScalings3DInto(0, mappingDestinationCorrect, translationDestination, nullptr, nullptr);
+    scene.translationsRotationsScalings3DInto(0, mappingDestinationCorrect, nullptr, rotationDestination, nullptr);
+    scene.translationsRotationsScalings3DInto(0, mappingDestinationCorrect, nullptr, nullptr, scalingDestination);
     scene.translationsRotationsScalings3DInto(0, nullptr, translationDestinationCorrect, rotationDestination, nullptr);
     scene.translationsRotationsScalings3DInto(0, nullptr, translationDestinationCorrect, nullptr, scalingDestination);
     scene.translationsRotationsScalings3DInto(0, nullptr, nullptr, rotationDestinationCorrect, scalingDestination);
     CORRADE_COMPARE(out.str(),
-        "Trade::SceneData::translationsRotationsScalings3DInto(): expected object destination view either empty or with 3 elements but got 2\n"
+        "Trade::SceneData::translationsRotationsScalings3DInto(): expected mapping destination view either empty or with 3 elements but got 2\n"
         "Trade::SceneData::translationsRotationsScalings3DInto(): expected translation destination view either empty or with 3 elements but got 2\n"
         "Trade::SceneData::translationsRotationsScalings3DInto(): expected rotation destination view either empty or with 3 elements but got 2\n"
         "Trade::SceneData::translationsRotationsScalings3DInto(): expected scaling destination view either empty or with 3 elements but got 2\n"
         "Trade::SceneData::translationsRotationsScalings3DInto(): offset 4 out of bounds for a field of size 3\n"
-        "Trade::SceneData::translationsRotationsScalings3DInto(): object and translation destination views have different size, 3 vs 2\n"
-        "Trade::SceneData::translationsRotationsScalings3DInto(): object and rotation destination views have different size, 3 vs 2\n"
-        "Trade::SceneData::translationsRotationsScalings3DInto(): object and scaling destination views have different size, 3 vs 2\n"
+        "Trade::SceneData::translationsRotationsScalings3DInto(): mapping and translation destination views have different size, 3 vs 2\n"
+        "Trade::SceneData::translationsRotationsScalings3DInto(): mapping and rotation destination views have different size, 3 vs 2\n"
+        "Trade::SceneData::translationsRotationsScalings3DInto(): mapping and scaling destination views have different size, 3 vs 2\n"
         "Trade::SceneData::translationsRotationsScalings3DInto(): translation and rotation destination views have different size, 3 vs 2\n"
         "Trade::SceneData::translationsRotationsScalings3DInto(): translation and scaling destination views have different size, 3 vs 2\n"
         "Trade::SceneData::translationsRotationsScalings3DInto(): rotation and scaling destination views have different size, 3 vs 2\n");
@@ -3749,9 +3749,9 @@ template<class T, class U> void SceneDataTest::meshesMaterialsAsArray() {
 
     /* Both meshes and materials */
     {
-        SceneData scene{SceneObjectType::UnsignedByte, 50, {}, fields, {
+        SceneData scene{SceneMappingType::UnsignedByte, 50, {}, fields, {
             /* To verify it isn't just picking the first ever field */
-            SceneFieldData{SceneField::Parent, SceneObjectType::UnsignedByte, nullptr, SceneFieldType::Int, nullptr},
+            SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedByte, nullptr, SceneFieldType::Int, nullptr},
             meshes,
             meshMaterials
         }};
@@ -3764,7 +3764,7 @@ template<class T, class U> void SceneDataTest::meshesMaterialsAsArray() {
 
     /* Only meshes */
     } {
-        SceneData scene{SceneObjectType::UnsignedByte, 50, {}, fields, {
+        SceneData scene{SceneMappingType::UnsignedByte, 50, {}, fields, {
             meshes
         }};
 
@@ -3796,9 +3796,9 @@ void SceneDataTest::meshesMaterialsIntoArray() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
         /* To verify it isn't just picking the first ever field */
-        SceneFieldData{SceneField::Parent, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
+        SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
         SceneFieldData{SceneField::Mesh,
             view.slice(&Field::object),
             view.slice(&Field::mesh)},
@@ -3809,15 +3809,15 @@ void SceneDataTest::meshesMaterialsIntoArray() {
 
     /* The offset-less overload should give back all data */
     {
-        UnsignedInt objects[3];
+        UnsignedInt mapping[3];
         UnsignedInt meshes[3];
         Int meshMaterials[3];
         scene.meshesMaterialsInto(
-            data.objects ? Containers::arrayView(objects) : nullptr,
+            data.mapping ? Containers::arrayView(mapping) : nullptr,
             data.field1 ? Containers::arrayView(meshes) : nullptr,
             data.field2 ? Containers::arrayView(meshMaterials) : nullptr
         );
-        if(data.objects) CORRADE_COMPARE_AS(Containers::stridedArrayView(objects),
+        if(data.mapping) CORRADE_COMPARE_AS(Containers::stridedArrayView(mapping),
             view.slice(&Field::object),
             TestSuite::Compare::Container);
         if(data.field1) CORRADE_COMPARE_AS(Containers::stridedArrayView(meshes),
@@ -3829,15 +3829,15 @@ void SceneDataTest::meshesMaterialsIntoArray() {
 
     /* The offset variant should give back only a subset */
     } {
-        Containers::Array<UnsignedInt> objects{data.size};
+        Containers::Array<UnsignedInt> mapping{data.size};
         Containers::Array<UnsignedInt> meshes{data.size};
         Containers::Array<Int> meshMaterials{data.size};
         CORRADE_COMPARE(scene.meshesMaterialsInto(data.offset,
-            data.objects ? arrayView(objects) : nullptr,
+            data.mapping ? arrayView(mapping) : nullptr,
             data.field1 ? arrayView(meshes) : nullptr,
             data.field2 ? arrayView(meshMaterials) : nullptr
         ), data.expectedSize);
-        if(data.objects) CORRADE_COMPARE_AS(objects.prefix(data.expectedSize),
+        if(data.mapping) CORRADE_COMPARE_AS(mapping.prefix(data.expectedSize),
             view.slice(&Field::object)
                 .slice(data.offset, data.offset + data.expectedSize),
             TestSuite::Compare::Container);
@@ -3864,32 +3864,32 @@ void SceneDataTest::meshesMaterialsIntoArrayInvalidSizeOrOffset() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
         SceneFieldData{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh)}
     }};
 
     std::ostringstream out;
     Error redirectError{&out};
-    UnsignedInt objectDestinationCorrect[3];
-    UnsignedInt objectDestination[2];
+    UnsignedInt mappingDestinationCorrect[3];
+    UnsignedInt mappingDestination[2];
     UnsignedInt meshDestinationCorrect[3];
     UnsignedInt meshDestination[2];
     Int meshMaterialDestinationCorrect[3];
     Int meshMaterialDestination[2];
-    scene.meshesMaterialsInto(objectDestination, meshDestinationCorrect, meshMaterialDestinationCorrect);
-    scene.meshesMaterialsInto(objectDestinationCorrect, meshDestination, meshMaterialDestinationCorrect);
-    scene.meshesMaterialsInto(objectDestinationCorrect, meshDestinationCorrect, meshMaterialDestination);
-    scene.meshesMaterialsInto(4, objectDestination, meshDestination, meshMaterialDestination);
-    scene.meshesMaterialsInto(0, objectDestinationCorrect, meshDestination, nullptr);
-    scene.meshesMaterialsInto(0, objectDestinationCorrect, nullptr, meshMaterialDestination);
+    scene.meshesMaterialsInto(mappingDestination, meshDestinationCorrect, meshMaterialDestinationCorrect);
+    scene.meshesMaterialsInto(mappingDestinationCorrect, meshDestination, meshMaterialDestinationCorrect);
+    scene.meshesMaterialsInto(mappingDestinationCorrect, meshDestinationCorrect, meshMaterialDestination);
+    scene.meshesMaterialsInto(4, mappingDestination, meshDestination, meshMaterialDestination);
+    scene.meshesMaterialsInto(0, mappingDestinationCorrect, meshDestination, nullptr);
+    scene.meshesMaterialsInto(0, mappingDestinationCorrect, nullptr, meshMaterialDestination);
     scene.meshesMaterialsInto(0, nullptr, meshDestinationCorrect, meshMaterialDestination);
     CORRADE_COMPARE(out.str(),
-        "Trade::SceneData::meshesMaterialsInto(): expected object destination view either empty or with 3 elements but got 2\n"
+        "Trade::SceneData::meshesMaterialsInto(): expected mapping destination view either empty or with 3 elements but got 2\n"
         "Trade::SceneData::meshesMaterialsInto(): expected mesh destination view either empty or with 3 elements but got 2\n"
         "Trade::SceneData::meshesMaterialsInto(): expected mesh material destination view either empty or with 3 elements but got 2\n"
         "Trade::SceneData::meshesMaterialsInto(): offset 4 out of bounds for a field of size 3\n"
-        "Trade::SceneData::meshesMaterialsInto(): object and mesh destination views have different size, 3 vs 2\n"
-        "Trade::SceneData::meshesMaterialsInto(): object and mesh material destination views have different size, 3 vs 2\n"
+        "Trade::SceneData::meshesMaterialsInto(): mapping and mesh destination views have different size, 3 vs 2\n"
+        "Trade::SceneData::meshesMaterialsInto(): mapping and mesh material destination views have different size, 3 vs 2\n"
         "Trade::SceneData::meshesMaterialsInto(): mesh and mesh material destination views have different size, 3 vs 2\n");
 }
 
@@ -3907,9 +3907,9 @@ template<class T> void SceneDataTest::lightsAsArray() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedByte, 50, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedByte, 50, {}, fields, {
         /* To verify it isn't just picking the first ever field */
-        SceneFieldData{SceneField::Parent, SceneObjectType::UnsignedByte, nullptr, SceneFieldType::Int, nullptr},
+        SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedByte, nullptr, SceneFieldType::Int, nullptr},
         SceneFieldData{SceneField::Light, view.slice(&Field::object), view.slice(&Field::light)}
     }};
 
@@ -3939,9 +3939,9 @@ void SceneDataTest::lightsIntoArray() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
         /* To verify it isn't just picking the first ever field */
-        SceneFieldData{SceneField::Parent, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
+        SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
         SceneFieldData{SceneField::Light,
             view.slice(&Field::object),
             view.slice(&Field::light)},
@@ -3949,13 +3949,13 @@ void SceneDataTest::lightsIntoArray() {
 
     /* The offset-less overload should give back all data */
     {
-        UnsignedInt objects[3];
+        UnsignedInt mapping[3];
         UnsignedInt field[3];
         scene.lightsInto(
-            data.objects ? Containers::arrayView(objects) : nullptr,
+            data.mapping ? Containers::arrayView(mapping) : nullptr,
             data.field ? Containers::arrayView(field) : nullptr
         );
-        if(data.objects) CORRADE_COMPARE_AS(Containers::stridedArrayView(objects),
+        if(data.mapping) CORRADE_COMPARE_AS(Containers::stridedArrayView(mapping),
             view.slice(&Field::object),
             TestSuite::Compare::Container);
         if(data.field) CORRADE_COMPARE_AS(Containers::stridedArrayView(field),
@@ -3964,13 +3964,13 @@ void SceneDataTest::lightsIntoArray() {
 
     /* The offset variant only a subset */
     } {
-        Containers::Array<UnsignedInt> objects{data.size};
+        Containers::Array<UnsignedInt> mapping{data.size};
         Containers::Array<UnsignedInt> field{data.size};
         CORRADE_COMPARE(scene.lightsInto(data.offset,
-            data.objects ? arrayView(objects) : nullptr,
+            data.mapping ? arrayView(mapping) : nullptr,
             data.field ? arrayView(field) : nullptr
         ), data.expectedSize);
-        if(data.objects) CORRADE_COMPARE_AS(objects.prefix(data.expectedSize),
+        if(data.mapping) CORRADE_COMPARE_AS(mapping.prefix(data.expectedSize),
             view.slice(&Field::object)
                 .slice(data.offset, data.offset + data.expectedSize),
             TestSuite::Compare::Container);
@@ -3993,25 +3993,25 @@ void SceneDataTest::lightsIntoArrayInvalidSizeOrOffset() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
         SceneFieldData{SceneField::Light, view.slice(&Field::object), view.slice(&Field::light)}
     }};
 
     std::ostringstream out;
     Error redirectError{&out};
-    UnsignedInt objectDestinationCorrect[3];
-    UnsignedInt objectDestination[2];
+    UnsignedInt mappingDestinationCorrect[3];
+    UnsignedInt mappingDestination[2];
     UnsignedInt fieldDestinationCorrect[3];
     UnsignedInt fieldDestination[2];
-    scene.lightsInto(objectDestination, fieldDestinationCorrect);
-    scene.lightsInto(objectDestinationCorrect, fieldDestination);
-    scene.lightsInto(4, objectDestination, fieldDestination);
-    scene.lightsInto(0, objectDestinationCorrect, fieldDestination);
+    scene.lightsInto(mappingDestination, fieldDestinationCorrect);
+    scene.lightsInto(mappingDestinationCorrect, fieldDestination);
+    scene.lightsInto(4, mappingDestination, fieldDestination);
+    scene.lightsInto(0, mappingDestinationCorrect, fieldDestination);
     CORRADE_COMPARE(out.str(),
-        "Trade::SceneData::lightsInto(): expected object destination view either empty or with 3 elements but got 2\n"
+        "Trade::SceneData::lightsInto(): expected mapping destination view either empty or with 3 elements but got 2\n"
         "Trade::SceneData::lightsInto(): expected field destination view either empty or with 3 elements but got 2\n"
         "Trade::SceneData::lightsInto(): offset 4 out of bounds for a field of size 3\n"
-        "Trade::SceneData::lightsInto(): object and field destination views have different size, 3 vs 2\n");
+        "Trade::SceneData::lightsInto(): mapping and field destination views have different size, 3 vs 2\n");
 }
 
 template<class T> void SceneDataTest::camerasAsArray() {
@@ -4028,9 +4028,9 @@ template<class T> void SceneDataTest::camerasAsArray() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedByte, 50, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedByte, 50, {}, fields, {
         /* To verify it isn't just picking the first ever field */
-        SceneFieldData{SceneField::Parent, SceneObjectType::UnsignedByte, nullptr, SceneFieldType::Int, nullptr},
+        SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedByte, nullptr, SceneFieldType::Int, nullptr},
         SceneFieldData{SceneField::Camera, view.slice(&Field::object), view.slice(&Field::camera)}
     }};
 
@@ -4060,9 +4060,9 @@ void SceneDataTest::camerasIntoArray() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
         /* To verify it isn't just picking the first ever field */
-        SceneFieldData{SceneField::Parent, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
+        SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
         SceneFieldData{SceneField::Camera,
             view.slice(&Field::object),
             view.slice(&Field::camera)},
@@ -4070,13 +4070,13 @@ void SceneDataTest::camerasIntoArray() {
 
     /* The offset-less overload should give back all data */
     {
-        UnsignedInt objects[3];
+        UnsignedInt mapping[3];
         UnsignedInt field[3];
         scene.camerasInto(
-            data.objects ? Containers::arrayView(objects) : nullptr,
+            data.mapping ? Containers::arrayView(mapping) : nullptr,
             data.field ? Containers::arrayView(field) : nullptr
         );
-        if(data.objects) CORRADE_COMPARE_AS(Containers::stridedArrayView(objects),
+        if(data.mapping) CORRADE_COMPARE_AS(Containers::stridedArrayView(mapping),
             view.slice(&Field::object),
             TestSuite::Compare::Container);
         if(data.field) CORRADE_COMPARE_AS(Containers::stridedArrayView(field),
@@ -4085,13 +4085,13 @@ void SceneDataTest::camerasIntoArray() {
 
     /* The offset variant only a subset */
     } {
-        Containers::Array<UnsignedInt> objects{data.size};
+        Containers::Array<UnsignedInt> mapping{data.size};
         Containers::Array<UnsignedInt> field{data.size};
         CORRADE_COMPARE(scene.camerasInto(data.offset,
-            data.objects ? arrayView(objects) : nullptr,
+            data.mapping ? arrayView(mapping) : nullptr,
             data.field ? arrayView(field) : nullptr
         ), data.expectedSize);
-        if(data.objects) CORRADE_COMPARE_AS(objects.prefix(data.expectedSize),
+        if(data.mapping) CORRADE_COMPARE_AS(mapping.prefix(data.expectedSize),
             view.slice(&Field::object)
                 .slice(data.offset, data.offset + data.expectedSize),
             TestSuite::Compare::Container);
@@ -4114,25 +4114,25 @@ void SceneDataTest::camerasIntoArrayInvalidSizeOrOffset() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
         SceneFieldData{SceneField::Camera, view.slice(&Field::object), view.slice(&Field::camera)}
     }};
 
     std::ostringstream out;
     Error redirectError{&out};
-    UnsignedInt objectDestinationCorrect[3];
-    UnsignedInt objectDestination[2];
+    UnsignedInt mappingDestinationCorrect[3];
+    UnsignedInt mappingDestination[2];
     UnsignedInt fieldDestinationCorrect[3];
     UnsignedInt fieldDestination[2];
-    scene.camerasInto(objectDestination, fieldDestinationCorrect);
-    scene.camerasInto(objectDestinationCorrect, fieldDestination);
-    scene.camerasInto(4, objectDestination, fieldDestination);
-    scene.camerasInto(0, objectDestinationCorrect, fieldDestination);
+    scene.camerasInto(mappingDestination, fieldDestinationCorrect);
+    scene.camerasInto(mappingDestinationCorrect, fieldDestination);
+    scene.camerasInto(4, mappingDestination, fieldDestination);
+    scene.camerasInto(0, mappingDestinationCorrect, fieldDestination);
     CORRADE_COMPARE(out.str(),
-        "Trade::SceneData::camerasInto(): expected object destination view either empty or with 3 elements but got 2\n"
+        "Trade::SceneData::camerasInto(): expected mapping destination view either empty or with 3 elements but got 2\n"
         "Trade::SceneData::camerasInto(): expected field destination view either empty or with 3 elements but got 2\n"
         "Trade::SceneData::camerasInto(): offset 4 out of bounds for a field of size 3\n"
-        "Trade::SceneData::camerasInto(): object and field destination views have different size, 3 vs 2\n");
+        "Trade::SceneData::camerasInto(): mapping and field destination views have different size, 3 vs 2\n");
 }
 
 template<class T> void SceneDataTest::skinsAsArray() {
@@ -4149,11 +4149,11 @@ template<class T> void SceneDataTest::skinsAsArray() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedByte, 50, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedByte, 50, {}, fields, {
         /* To verify it isn't just picking the first ever field; also to
            satisfy the requirement of having a transformation field to
            disambiguate the dimensionality */
-        SceneFieldData{SceneField::Translation, SceneObjectType::UnsignedByte, nullptr, SceneFieldType::Vector3, nullptr},
+        SceneFieldData{SceneField::Translation, SceneMappingType::UnsignedByte, nullptr, SceneFieldType::Vector3, nullptr},
         SceneFieldData{SceneField::Skin, view.slice(&Field::object), view.slice(&Field::skin)}
     }};
 
@@ -4183,11 +4183,11 @@ void SceneDataTest::skinsIntoArray() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
         /* To verify it isn't just picking the first ever field; also to
            satisfy the requirement of having a transformation field to
            disambiguate the dimensionality */
-        SceneFieldData{SceneField::Translation, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Vector3, nullptr},
+        SceneFieldData{SceneField::Translation, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Vector3, nullptr},
         SceneFieldData{SceneField::Skin,
             view.slice(&Field::object),
             view.slice(&Field::skin)},
@@ -4195,13 +4195,13 @@ void SceneDataTest::skinsIntoArray() {
 
     /* The offset-less overload should give back all data */
     {
-        UnsignedInt objects[3];
+        UnsignedInt mapping[3];
         UnsignedInt field[3];
         scene.skinsInto(
-            data.objects ? Containers::arrayView(objects) : nullptr,
+            data.mapping ? Containers::arrayView(mapping) : nullptr,
             data.field ? Containers::arrayView(field) : nullptr
         );
-        if(data.objects) CORRADE_COMPARE_AS(Containers::stridedArrayView(objects),
+        if(data.mapping) CORRADE_COMPARE_AS(Containers::stridedArrayView(mapping),
             view.slice(&Field::object),
             TestSuite::Compare::Container);
         if(data.field) CORRADE_COMPARE_AS(Containers::stridedArrayView(field),
@@ -4210,13 +4210,13 @@ void SceneDataTest::skinsIntoArray() {
 
     /* The offset variant only a subset */
     } {
-        Containers::Array<UnsignedInt> objects{data.size};
+        Containers::Array<UnsignedInt> mapping{data.size};
         Containers::Array<UnsignedInt> field{data.size};
         CORRADE_COMPARE(scene.skinsInto(data.offset,
-            data.objects ? arrayView(objects) : nullptr,
+            data.mapping ? arrayView(mapping) : nullptr,
             data.field ? arrayView(field) : nullptr
         ), data.expectedSize);
-        if(data.objects) CORRADE_COMPARE_AS(objects.prefix(data.expectedSize),
+        if(data.mapping) CORRADE_COMPARE_AS(mapping.prefix(data.expectedSize),
             view.slice(&Field::object)
                 .slice(data.offset, data.offset + data.expectedSize),
             TestSuite::Compare::Container);
@@ -4239,28 +4239,28 @@ void SceneDataTest::skinsIntoArrayInvalidSizeOrOffset() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
         /* To satisfy the requirement of having a transformation field to
            disambiguate the dimensionality */
-        SceneFieldData{SceneField::Translation, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Vector3, nullptr},
+        SceneFieldData{SceneField::Translation, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Vector3, nullptr},
         SceneFieldData{SceneField::Skin, view.slice(&Field::object), view.slice(&Field::skin)}
     }};
 
     std::ostringstream out;
     Error redirectError{&out};
-    UnsignedInt objectDestinationCorrect[3];
-    UnsignedInt objectDestination[2];
+    UnsignedInt mappingDestinationCorrect[3];
+    UnsignedInt mappingDestination[2];
     UnsignedInt fieldDestinationCorrect[3];
     UnsignedInt fieldDestination[2];
-    scene.skinsInto(objectDestination, fieldDestinationCorrect);
-    scene.skinsInto(objectDestinationCorrect, fieldDestination);
-    scene.skinsInto(4, objectDestination, fieldDestination);
-    scene.skinsInto(0, objectDestinationCorrect, fieldDestination);
+    scene.skinsInto(mappingDestination, fieldDestinationCorrect);
+    scene.skinsInto(mappingDestinationCorrect, fieldDestination);
+    scene.skinsInto(4, mappingDestination, fieldDestination);
+    scene.skinsInto(0, mappingDestinationCorrect, fieldDestination);
     CORRADE_COMPARE(out.str(),
-        "Trade::SceneData::skinsInto(): expected object destination view either empty or with 3 elements but got 2\n"
+        "Trade::SceneData::skinsInto(): expected mapping destination view either empty or with 3 elements but got 2\n"
         "Trade::SceneData::skinsInto(): expected field destination view either empty or with 3 elements but got 2\n"
         "Trade::SceneData::skinsInto(): offset 4 out of bounds for a field of size 3\n"
-        "Trade::SceneData::skinsInto(): object and field destination views have different size, 3 vs 2\n");
+        "Trade::SceneData::skinsInto(): mapping and field destination views have different size, 3 vs 2\n");
 }
 
 template<class T> void SceneDataTest::importerStateAsArray() {
@@ -4279,9 +4279,9 @@ template<class T> void SceneDataTest::importerStateAsArray() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedByte, 50, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedByte, 50, {}, fields, {
         /* To verify it isn't just picking the first ever field */
-        SceneFieldData{SceneField::Parent, SceneObjectType::UnsignedByte, nullptr, SceneFieldType::Int, nullptr},
+        SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedByte, nullptr, SceneFieldType::Int, nullptr},
         SceneFieldData{SceneField::ImporterState, view.slice(&Field::object), view.slice(&Field::importerState)}
     }};
 
@@ -4313,9 +4313,9 @@ void SceneDataTest::importerStateIntoArray() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
         /* To verify it isn't just picking the first ever field */
-        SceneFieldData{SceneField::Parent, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
+        SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
         SceneFieldData{SceneField::ImporterState,
             view.slice(&Field::object),
             view.slice(&Field::importerState)},
@@ -4323,13 +4323,13 @@ void SceneDataTest::importerStateIntoArray() {
 
     /* The offset-less overload should give back all data */
     {
-        UnsignedInt objects[3];
+        UnsignedInt mapping[3];
         const void* field[3];
         scene.importerStateInto(
-            data.objects ? Containers::arrayView(objects) : nullptr,
+            data.mapping ? Containers::arrayView(mapping) : nullptr,
             data.field ? Containers::arrayView(field) : nullptr
         );
-        if(data.objects) CORRADE_COMPARE_AS(Containers::stridedArrayView(objects),
+        if(data.mapping) CORRADE_COMPARE_AS(Containers::stridedArrayView(mapping),
             view.slice(&Field::object),
             TestSuite::Compare::Container);
         if(data.field) CORRADE_COMPARE_AS(Containers::stridedArrayView(field),
@@ -4338,13 +4338,13 @@ void SceneDataTest::importerStateIntoArray() {
 
     /* The offset variant only a subset */
     } {
-        Containers::Array<UnsignedInt> objects{data.size};
+        Containers::Array<UnsignedInt> mapping{data.size};
         Containers::Array<const void*> field{data.size};
         CORRADE_COMPARE(scene.importerStateInto(data.offset,
-            data.objects ? arrayView(objects) : nullptr,
+            data.mapping ? arrayView(mapping) : nullptr,
             data.field ? arrayView(field) : nullptr
         ), data.expectedSize);
-        if(data.objects) CORRADE_COMPARE_AS(objects.prefix(data.expectedSize),
+        if(data.mapping) CORRADE_COMPARE_AS(mapping.prefix(data.expectedSize),
             view.slice(&Field::object)
                 .slice(data.offset, data.offset + data.expectedSize),
             TestSuite::Compare::Container);
@@ -4367,25 +4367,25 @@ void SceneDataTest::importerStateIntoArrayInvalidSizeOrOffset() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
         SceneFieldData{SceneField::ImporterState, view.slice(&Field::object), view.slice(&Field::importerState)}
     }};
 
     std::ostringstream out;
     Error redirectError{&out};
-    UnsignedInt objectDestinationCorrect[3];
-    UnsignedInt objectDestination[2];
+    UnsignedInt mappingDestinationCorrect[3];
+    UnsignedInt mappingDestination[2];
     const void* fieldDestinationCorrect[3];
     const void* fieldDestination[2];
-    scene.importerStateInto(objectDestination, fieldDestinationCorrect);
-    scene.importerStateInto(objectDestinationCorrect, fieldDestination);
-    scene.importerStateInto(4, objectDestination, fieldDestination);
-    scene.importerStateInto(0, objectDestinationCorrect, fieldDestination);
+    scene.importerStateInto(mappingDestination, fieldDestinationCorrect);
+    scene.importerStateInto(mappingDestinationCorrect, fieldDestination);
+    scene.importerStateInto(4, mappingDestination, fieldDestination);
+    scene.importerStateInto(0, mappingDestinationCorrect, fieldDestination);
     CORRADE_COMPARE(out.str(),
-        "Trade::SceneData::importerStateInto(): expected object destination view either empty or with 3 elements but got 2\n"
+        "Trade::SceneData::importerStateInto(): expected mapping destination view either empty or with 3 elements but got 2\n"
         "Trade::SceneData::importerStateInto(): expected field destination view either empty or with 3 elements but got 2\n"
         "Trade::SceneData::importerStateInto(): offset 4 out of bounds for a field of size 3\n"
-        "Trade::SceneData::importerStateInto(): object and field destination views have different size, 3 vs 2\n");
+        "Trade::SceneData::importerStateInto(): mapping and field destination views have different size, 3 vs 2\n");
 }
 
 void SceneDataTest::mutableAccessNotAllowed() {
@@ -4401,7 +4401,7 @@ void SceneDataTest::mutableAccessNotAllowed() {
 
     Containers::StridedArrayView1D<const Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
         SceneFieldData{sceneFieldCustom(35),
             view.slice(&Field::object),
             view.slice(&Field::foobar)},
@@ -4413,10 +4413,10 @@ void SceneDataTest::mutableAccessNotAllowed() {
     std::ostringstream out;
     Error redirectError{&out};
     scene.mutableData();
-    scene.mutableObjects(0);
-    scene.mutableObjects<UnsignedInt>(0);
-    scene.mutableObjects(SceneField::Mesh);
-    scene.mutableObjects<UnsignedInt>(SceneField::Mesh);
+    scene.mutableMapping(0);
+    scene.mutableMapping<UnsignedInt>(0);
+    scene.mutableMapping(SceneField::Mesh);
+    scene.mutableMapping<UnsignedInt>(SceneField::Mesh);
     scene.mutableField(0);
     scene.mutableField<UnsignedInt>(0);
     scene.mutableField<UnsignedInt[]>(1);
@@ -4425,10 +4425,10 @@ void SceneDataTest::mutableAccessNotAllowed() {
     scene.mutableField<UnsignedInt[]>(sceneFieldCustom(35));
     CORRADE_COMPARE(out.str(),
         "Trade::SceneData::mutableData(): data not mutable\n"
-        "Trade::SceneData::mutableObjects(): data not mutable\n"
-        "Trade::SceneData::mutableObjects(): data not mutable\n"
-        "Trade::SceneData::mutableObjects(): data not mutable\n"
-        "Trade::SceneData::mutableObjects(): data not mutable\n"
+        "Trade::SceneData::mutableMapping(): data not mutable\n"
+        "Trade::SceneData::mutableMapping(): data not mutable\n"
+        "Trade::SceneData::mutableMapping(): data not mutable\n"
+        "Trade::SceneData::mutableMapping(): data not mutable\n"
         "Trade::SceneData::mutableField(): data not mutable\n"
         "Trade::SceneData::mutableField(): data not mutable\n"
         "Trade::SceneData::mutableField(): data not mutable\n"
@@ -4437,7 +4437,7 @@ void SceneDataTest::mutableAccessNotAllowed() {
         "Trade::SceneData::mutableField(): data not mutable\n");
 }
 
-void SceneDataTest::objectsNotFound() {
+void SceneDataTest::mappingNotFound() {
     #ifdef CORRADE_NO_ASSERT
     CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
     #endif
@@ -4450,39 +4450,39 @@ void SceneDataTest::objectsNotFound() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, DataFlag::Mutable, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, DataFlag::Mutable, fields, {
         SceneFieldData{sceneFieldCustom(35), view.slice(&Field::object), view.slice(&Field::foobar)},
         SceneFieldData{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh)},
     }};
 
     std::ostringstream out;
     Error redirectError{&out};
-    scene.objects(2);
-    scene.objects<UnsignedInt>(2);
-    scene.mutableObjects(2);
-    scene.mutableObjects<UnsignedInt>(2);
-    scene.objects(sceneFieldCustom(666));
-    scene.objects<UnsignedInt>(sceneFieldCustom(666));
-    scene.mutableObjects(sceneFieldCustom(666));
-    scene.mutableObjects<UnsignedInt>(sceneFieldCustom(666));
-
-    scene.objectsAsArray(2);
-    scene.objectsAsArray(sceneFieldCustom(666));
+    scene.mapping(2);
+    scene.mapping<UnsignedInt>(2);
+    scene.mutableMapping(2);
+    scene.mutableMapping<UnsignedInt>(2);
+    scene.mapping(sceneFieldCustom(666));
+    scene.mapping<UnsignedInt>(sceneFieldCustom(666));
+    scene.mutableMapping(sceneFieldCustom(666));
+    scene.mutableMapping<UnsignedInt>(sceneFieldCustom(666));
+
+    scene.mappingAsArray(2);
+    scene.mappingAsArray(sceneFieldCustom(666));
     CORRADE_COMPARE(out.str(),
-        "Trade::SceneData::objects(): index 2 out of range for 2 fields\n"
-        "Trade::SceneData::objects(): index 2 out of range for 2 fields\n"
-        "Trade::SceneData::mutableObjects(): index 2 out of range for 2 fields\n"
-        "Trade::SceneData::mutableObjects(): index 2 out of range for 2 fields\n"
-        "Trade::SceneData::objects(): field Trade::SceneField::Custom(666) not found\n"
-        "Trade::SceneData::objects(): field Trade::SceneField::Custom(666) not found\n"
-        "Trade::SceneData::mutableObjects(): field Trade::SceneField::Custom(666) not found\n"
-        "Trade::SceneData::mutableObjects(): field Trade::SceneField::Custom(666) not found\n"
-
-        "Trade::SceneData::objectsInto(): index 2 out of range for 2 fields\n"
-        "Trade::SceneData::objectsInto(): field Trade::SceneField::Custom(666) not found\n");
+        "Trade::SceneData::mapping(): index 2 out of range for 2 fields\n"
+        "Trade::SceneData::mapping(): index 2 out of range for 2 fields\n"
+        "Trade::SceneData::mutableMapping(): index 2 out of range for 2 fields\n"
+        "Trade::SceneData::mutableMapping(): index 2 out of range for 2 fields\n"
+        "Trade::SceneData::mapping(): field Trade::SceneField::Custom(666) not found\n"
+        "Trade::SceneData::mapping(): field Trade::SceneField::Custom(666) not found\n"
+        "Trade::SceneData::mutableMapping(): field Trade::SceneField::Custom(666) not found\n"
+        "Trade::SceneData::mutableMapping(): field Trade::SceneField::Custom(666) not found\n"
+
+        "Trade::SceneData::mappingInto(): index 2 out of range for 2 fields\n"
+        "Trade::SceneData::mappingInto(): field Trade::SceneField::Custom(666) not found\n");
 }
 
-void SceneDataTest::objectsWrongType() {
+void SceneDataTest::mappingWrongType() {
     #ifdef CORRADE_NO_ASSERT
     CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
     #endif
@@ -4495,22 +4495,22 @@ void SceneDataTest::objectsWrongType() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedShort, 5, DataFlag::Mutable, fields, {
+    SceneData scene{SceneMappingType::UnsignedShort, 5, DataFlag::Mutable, fields, {
         SceneFieldData{sceneFieldCustom(35), view.slice(&Field::object), view.slice(&Field::foobar)},
         SceneFieldData{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh)},
     }};
 
     std::ostringstream out;
     Error redirectError{&out};
-    scene.objects<UnsignedByte>(1);
-    scene.mutableObjects<UnsignedByte>(1);
-    scene.objects<UnsignedByte>(SceneField::Mesh);
-    scene.mutableObjects<UnsignedByte>(SceneField::Mesh);
+    scene.mapping<UnsignedByte>(1);
+    scene.mutableMapping<UnsignedByte>(1);
+    scene.mapping<UnsignedByte>(SceneField::Mesh);
+    scene.mutableMapping<UnsignedByte>(SceneField::Mesh);
     CORRADE_COMPARE(out.str(),
-        "Trade::SceneData::objects(): objects are Trade::SceneObjectType::UnsignedShort but requested Trade::SceneObjectType::UnsignedByte\n"
-        "Trade::SceneData::mutableObjects(): objects are Trade::SceneObjectType::UnsignedShort but requested Trade::SceneObjectType::UnsignedByte\n"
-        "Trade::SceneData::objects(): objects are Trade::SceneObjectType::UnsignedShort but requested Trade::SceneObjectType::UnsignedByte\n"
-        "Trade::SceneData::mutableObjects(): objects are Trade::SceneObjectType::UnsignedShort but requested Trade::SceneObjectType::UnsignedByte\n");
+        "Trade::SceneData::mapping(): mapping is Trade::SceneMappingType::UnsignedShort but requested Trade::SceneMappingType::UnsignedByte\n"
+        "Trade::SceneData::mutableMapping(): mapping is Trade::SceneMappingType::UnsignedShort but requested Trade::SceneMappingType::UnsignedByte\n"
+        "Trade::SceneData::mapping(): mapping is Trade::SceneMappingType::UnsignedShort but requested Trade::SceneMappingType::UnsignedByte\n"
+        "Trade::SceneData::mutableMapping(): mapping is Trade::SceneMappingType::UnsignedShort but requested Trade::SceneMappingType::UnsignedByte\n");
 }
 
 void SceneDataTest::fieldNotFound() {
@@ -4525,7 +4525,7 @@ void SceneDataTest::fieldNotFound() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, DataFlag::Mutable, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, DataFlag::Mutable, fields, {
         SceneFieldData{sceneFieldCustom(34), view.slice(&Field::object), view.slice(&Field::foo)},
         SceneFieldData{sceneFieldCustom(35), view.slice(&Field::object), view.slice(&Field::bar)},
     }};
@@ -4669,7 +4669,7 @@ void SceneDataTest::fieldWrongType() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, DataFlag::Mutable, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, DataFlag::Mutable, fields, {
         SceneFieldData{sceneFieldCustom(35), view.slice(&Field::object), view.slice(&Field::foobar)},
         SceneFieldData{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh)},
     }};
@@ -4707,7 +4707,7 @@ void SceneDataTest::fieldWrongPointerType() {
     } things[2];
     Containers::StridedArrayView1D<Thing> view = things;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, DataFlag::Mutable, things, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, DataFlag::Mutable, things, {
         SceneFieldData{sceneFieldCustom(35), view.slice(&Thing::object), Containers::arrayCast<2, Int*>(view.slice(&Thing::foobar))},
         SceneFieldData{SceneField::ImporterState, view.slice(&Thing::object), view.slice(&Thing::importerState)},
     }};
@@ -4780,7 +4780,7 @@ void SceneDataTest::fieldWrongArrayAccess() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 5, DataFlag::Mutable, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 5, DataFlag::Mutable, fields, {
         SceneFieldData{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh)},
         SceneFieldData{sceneFieldCustom(35), view.slice(&Field::object), Containers::arrayCast<2, UnsignedInt>(view.slice(&Field::foobar))},
     }};
@@ -4818,7 +4818,7 @@ void SceneDataTest::parentFor() {
     };
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 7, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
         SceneFieldData{SceneField::Parent, view.slice(&Field::object), view.slice(&Field::parent)}
     }};
 
@@ -4843,7 +4843,7 @@ void SceneDataTest::parentForTrivialParent() {
         {3, 4, 2, 4 /* duplicate, ignored */}, {-1}
     }};
 
-    SceneData scene{SceneObjectType::UnsignedInt, 7, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
         SceneFieldData{SceneField::Parent,
             Containers::stridedArrayView(fields->object), Containers::stridedArrayView(fields->parent).broadcasted<0>(4)}
     }};
@@ -4873,7 +4873,7 @@ void SceneDataTest::childrenFor() {
     };
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 7, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
         SceneFieldData{SceneField::Parent, view.slice(&Field::object), view.slice(&Field::parent)}
     }};
 
@@ -4905,15 +4905,15 @@ void SceneDataTest::childrenForTrivialParent() {
     /* Going a bit overboard with the arrays, it makes the view creation below
        easier tho */
     struct Field {
-        UnsignedInt object[4];
+        UnsignedInt mapping[4];
         Int parent[1];
     } fields[]{{
         {3, 4, 2, 4 /* duplicate, gets put to the output */}, {-1}
     }};
 
-    SceneData scene{SceneObjectType::UnsignedInt, 7, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
         SceneFieldData{SceneField::Parent,
-            Containers::stridedArrayView(fields->object), Containers::stridedArrayView(fields->parent).broadcasted<0>(4)}
+            Containers::stridedArrayView(fields->mapping), Containers::stridedArrayView(fields->parent).broadcasted<0>(4)}
     }};
 
     /* Trivial children */
@@ -4944,7 +4944,7 @@ void SceneDataTest::transformation2DFor() {
     };
     Containers::StridedArrayView1D<const Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 7, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
         SceneFieldData{SceneField::Transformation, view.slice(&Field::object), view.slice(&Field::transformation)}
     }};
 
@@ -4977,7 +4977,7 @@ void SceneDataTest::transformation2DForTRS() {
     };
     Containers::StridedArrayView1D<const Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 7, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
         SceneFieldData{SceneField::Translation, view.slice(&Field::object), view.slice(&Field::translation)},
         SceneFieldData{SceneField::Rotation, view.slice(&Field::object), view.slice(&Field::rotation)},
         SceneFieldData{SceneField::Scaling, view.slice(&Field::object), view.slice(&Field::scaling)}
@@ -5011,8 +5011,8 @@ void SceneDataTest::transformation2DForBut3DType() {
     CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
     #endif
 
-    SceneData scene{SceneObjectType::UnsignedInt, 1, nullptr, {
-        SceneFieldData{SceneField::Translation, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Vector3, nullptr}
+    SceneData scene{SceneMappingType::UnsignedInt, 1, nullptr, {
+        SceneFieldData{SceneField::Translation, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Vector3, nullptr}
     }};
 
     std::ostringstream out;
@@ -5036,7 +5036,7 @@ void SceneDataTest::transformation3DFor() {
     };
     Containers::StridedArrayView1D<const Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 7, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
         SceneFieldData{SceneField::Transformation, view.slice(&Field::object), view.slice(&Field::transformation)}
     }};
 
@@ -5069,7 +5069,7 @@ void SceneDataTest::transformation3DForTRS() {
     };
     Containers::StridedArrayView1D<const Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 7, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
         SceneFieldData{SceneField::Translation, view.slice(&Field::object), view.slice(&Field::translation)},
         SceneFieldData{SceneField::Rotation, view.slice(&Field::object), view.slice(&Field::rotation)},
         SceneFieldData{SceneField::Scaling, view.slice(&Field::object), view.slice(&Field::scaling)}
@@ -5103,8 +5103,8 @@ void SceneDataTest::transformation3DForBut2DType() {
     CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
     #endif
 
-    SceneData scene{SceneObjectType::UnsignedInt, 1, nullptr, {
-        SceneFieldData{SceneField::Translation, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Vector2, nullptr}
+    SceneData scene{SceneMappingType::UnsignedInt, 1, nullptr, {
+        SceneFieldData{SceneField::Translation, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Vector2, nullptr}
     }};
 
     std::ostringstream out;
@@ -5130,7 +5130,7 @@ void SceneDataTest::meshesMaterialsFor() {
     };
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 7, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
         SceneFieldData{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh)},
         SceneFieldData{SceneField::MeshMaterial, view.slice(&Field::object), view.slice(&Field::meshMaterial)}
     }};
@@ -5167,7 +5167,7 @@ void SceneDataTest::lightsFor() {
     };
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 7, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
         SceneFieldData{SceneField::Light, view.slice(&Field::object), view.slice(&Field::light)}
     }};
 
@@ -5203,7 +5203,7 @@ void SceneDataTest::camerasFor() {
     };
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 7, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
         SceneFieldData{SceneField::Camera, view.slice(&Field::object), view.slice(&Field::camera)}
     }};
 
@@ -5239,10 +5239,10 @@ void SceneDataTest::skinsFor() {
     };
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 7, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
         /* To satisfy the requirement of having a transformation field to
            disambiguate the dimensionality */
-        SceneFieldData{SceneField::Translation, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Vector3, nullptr},
+        SceneFieldData{SceneField::Translation, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Vector3, nullptr},
         SceneFieldData{SceneField::Skin, view.slice(&Field::object), view.slice(&Field::skin)}
     }};
 
@@ -5281,7 +5281,7 @@ void SceneDataTest::importerStateFor() {
 
     Containers::StridedArrayView1D<Field> view = fields;
 
-    SceneData scene{SceneObjectType::UnsignedInt, 7, {}, fields, {
+    SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
         SceneFieldData{SceneField::ImporterState, view.slice(&Field::object), view.slice(&Field::importerState)}
     }};
 
@@ -5318,11 +5318,11 @@ void SceneDataTest::childrenDeprecated() {
     if(!data.skipParent)
         arrayAppend(fieldData, SceneFieldData{SceneField::Parent, view.slice(&Field::object), view.slice(&Field::parent)});
     if(data.is2D)
-        arrayAppend(fieldData, SceneFieldData{SceneField::Translation, SceneObjectType::UnsignedByte, nullptr, SceneFieldType::Vector2, nullptr});
+        arrayAppend(fieldData, SceneFieldData{SceneField::Translation, SceneMappingType::UnsignedByte, nullptr, SceneFieldType::Vector2, nullptr});
     if(data.is3D)
-        arrayAppend(fieldData, SceneFieldData{SceneField::Translation, SceneObjectType::UnsignedByte, nullptr, SceneFieldType::Vector3, nullptr});
+        arrayAppend(fieldData, SceneFieldData{SceneField::Translation, SceneMappingType::UnsignedByte, nullptr, SceneFieldType::Vector3, nullptr});
 
-    SceneData scene{SceneObjectType::UnsignedByte, 25, {}, fields, std::move(fieldData)};
+    SceneData scene{SceneMappingType::UnsignedByte, 25, {}, fields, std::move(fieldData)};
 
     if(!data.skipParent) {
         CORRADE_IGNORE_DEPRECATED_PUSH
@@ -5351,7 +5351,7 @@ void SceneDataTest::childrenDeprecated() {
 #endif
 
 void SceneDataTest::fieldForFieldMissing() {
-    SceneData scene{SceneObjectType::UnsignedInt, 7, nullptr, {}};
+    SceneData scene{SceneMappingType::UnsignedInt, 7, nullptr, {}};
 
     CORRADE_COMPARE(scene.parentFor(6), Containers::NullOpt);
     CORRADE_COMPARE_AS(scene.childrenFor(6),
@@ -5380,8 +5380,8 @@ void SceneDataTest::findFieldObjectOffsetInvalidObject() {
     CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
     #endif
 
-    SceneData scene{SceneObjectType::UnsignedInt, 7, nullptr, {
-        SceneFieldData{SceneField::Parent, SceneObjectType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
+    SceneData scene{SceneMappingType::UnsignedInt, 7, nullptr, {
+        SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
     }};
 
     std::ostringstream out;
@@ -5433,12 +5433,12 @@ void SceneDataTest::releaseFieldData() {
     Containers::StridedArrayView1D<Field> view = Containers::arrayCast<Field>(data);
 
     auto fields = Containers::array({
-        SceneFieldData{SceneField::Parent, SceneObjectType::UnsignedByte, nullptr, SceneFieldType::Int, nullptr},
+        SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedByte, nullptr, SceneFieldType::Int, nullptr},
         SceneFieldData{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh)}
     });
     SceneFieldData* originalFields = fields;
 
-    SceneData scene{SceneObjectType::UnsignedByte, 50, std::move(data), std::move(fields)};
+    SceneData scene{SceneMappingType::UnsignedByte, 50, std::move(data), std::move(fields)};
 
     Containers::Array<SceneFieldData> released = scene.releaseFieldData();
     CORRADE_COMPARE(released.data(), originalFields);
@@ -5451,8 +5451,8 @@ void SceneDataTest::releaseFieldData() {
     /* Data stays untouched, object count and type as well, as it con't result
        in any dangling data access */
     CORRADE_COMPARE(scene.data(), view.data());
-    CORRADE_COMPARE(scene.objectCount(), 50);
-    CORRADE_COMPARE(scene.objectType(), SceneObjectType::UnsignedByte);
+    CORRADE_COMPARE(scene.mappingBound(), 50);
+    CORRADE_COMPARE(scene.mappingType(), SceneMappingType::UnsignedByte);
 }
 
 void SceneDataTest::releaseData() {
@@ -5464,8 +5464,8 @@ void SceneDataTest::releaseData() {
     Containers::Array<char> data{NoInit, 3*sizeof(Field)};
     Containers::StridedArrayView1D<Field> view = Containers::arrayCast<Field>(data);
 
-    SceneData scene{SceneObjectType::UnsignedByte, 50, std::move(data), {
-        SceneFieldData{SceneField::Parent, SceneObjectType::UnsignedByte, nullptr, SceneFieldType::Int, nullptr},
+    SceneData scene{SceneMappingType::UnsignedByte, 50, std::move(data), {
+        SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedByte, nullptr, SceneFieldType::Int, nullptr},
         SceneFieldData{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh)}
     }};
 
@@ -5480,8 +5480,8 @@ void SceneDataTest::releaseData() {
 
     /* Object count and type stays untouched, as it con't result in any
        dangling data access */
-    CORRADE_COMPARE(scene.objectCount(), 50);
-    CORRADE_COMPARE(scene.objectType(), SceneObjectType::UnsignedByte);
+    CORRADE_COMPARE(scene.mappingBound(), 50);
+    CORRADE_COMPARE(scene.mappingType(), SceneMappingType::UnsignedByte);
 }
 
 }}}}
diff --git a/src/Magnum/Trade/Test/SceneToolsTest.cpp b/src/Magnum/Trade/Test/SceneToolsTest.cpp
index fabb93855..2cb3ae373 100644
--- a/src/Magnum/Trade/Test/SceneToolsTest.cpp
+++ b/src/Magnum/Trade/Test/SceneToolsTest.cpp
@@ -47,12 +47,12 @@ struct SceneToolsTest: TestSuite::Tester {
 
 struct {
     const char* name;
-    SceneObjectType objectType;
+    SceneMappingType objectType;
 } CombineData[]{
-    {"UnsignedByte output", SceneObjectType::UnsignedByte},
-    {"UnsignedShort output", SceneObjectType::UnsignedShort},
-    {"UnsignedInt output", SceneObjectType::UnsignedInt},
-    {"UnsignedLong output", SceneObjectType::UnsignedLong},
+    {"UnsignedByte output", SceneMappingType::UnsignedByte},
+    {"UnsignedShort output", SceneMappingType::UnsignedShort},
+    {"UnsignedInt output", SceneMappingType::UnsignedInt},
+    {"UnsignedLong output", SceneMappingType::UnsignedLong},
 };
 
 struct {
@@ -86,76 +86,76 @@ void SceneToolsTest::combine() {
     /* Testing the four possible object types, it should be possible to combine
        them */
 
-    const UnsignedInt meshObjects[]{45, 78, 23};
-    const UnsignedByte meshes[]{3, 5, 17};
+    const UnsignedInt meshMappingData[]{45, 78, 23};
+    const UnsignedByte meshFieldData[]{3, 5, 17};
 
-    const UnsignedShort parentObjects[]{33, 25};
-    const Short parents[]{-1, 33};
+    const UnsignedShort parentMappingData[]{33, 25};
+    const Short parentData[]{-1, 33};
 
-    const UnsignedByte translationObjects[]{16};
-    const Vector2d translations[]{{1.5, -0.5}};
+    const UnsignedByte translationMappingData[]{16};
+    const Vector2d translationFieldData[]{{1.5, -0.5}};
 
-    const UnsignedLong fooObjects[]{15, 23};
-    const Int foos[]{0, 1, 2, 3};
+    const UnsignedLong fooMappingData[]{15, 23};
+    const Int fooFieldData[]{0, 1, 2, 3};
 
     SceneData scene = Implementation::sceneCombine(data.objectType, 167, Containers::arrayView({
-        SceneFieldData{SceneField::Mesh, Containers::arrayView(meshObjects), Containers::arrayView(meshes)},
-        SceneFieldData{SceneField::Parent, Containers::arrayView(parentObjects), Containers::arrayView(parents)},
-        SceneFieldData{SceneField::Translation, Containers::arrayView(translationObjects), Containers::arrayView(translations)},
+        SceneFieldData{SceneField::Mesh, Containers::arrayView(meshMappingData), Containers::arrayView(meshFieldData)},
+        SceneFieldData{SceneField::Parent, Containers::arrayView(parentMappingData), Containers::arrayView(parentData)},
+        SceneFieldData{SceneField::Translation, Containers::arrayView(translationMappingData), Containers::arrayView(translationFieldData)},
         /* Array field */
-        SceneFieldData{sceneFieldCustom(15), Containers::arrayView(fooObjects), Containers::StridedArrayView2D<const Int>{foos, {2, 2}}},
+        SceneFieldData{sceneFieldCustom(15), Containers::arrayView(fooMappingData), Containers::StridedArrayView2D<const Int>{fooFieldData, {2, 2}}},
         /* Empty field */
         SceneFieldData{SceneField::Camera, Containers::ArrayView<const UnsignedByte>{}, Containers::ArrayView<const UnsignedShort>{}}
     }));
 
     CORRADE_COMPARE(scene.dataFlags(), DataFlag::Owned|DataFlag::Mutable);
-    CORRADE_COMPARE(scene.objectType(), data.objectType);
-    CORRADE_COMPARE(scene.objectCount(), 167);
+    CORRADE_COMPARE(scene.mappingType(), data.objectType);
+    CORRADE_COMPARE(scene.mappingBound(), 167);
     CORRADE_COMPARE(scene.fieldCount(), 5);
 
     CORRADE_COMPARE(scene.fieldName(0), SceneField::Mesh);
     CORRADE_COMPARE(scene.fieldType(0), SceneFieldType::UnsignedByte);
     CORRADE_COMPARE(scene.fieldArraySize(0), 0);
-    CORRADE_COMPARE_AS(scene.objectsAsArray(0), Containers::arrayView<UnsignedInt>({
+    CORRADE_COMPARE_AS(scene.mappingAsArray(0), Containers::arrayView<UnsignedInt>({
         45, 78, 23
     }), TestSuite::Compare::Container);
     CORRADE_COMPARE_AS(scene.field<UnsignedByte>(0),
-        Containers::arrayView(meshes),
+        Containers::arrayView(meshFieldData),
         TestSuite::Compare::Container);
 
     CORRADE_COMPARE(scene.fieldName(1), SceneField::Parent);
     CORRADE_COMPARE(scene.fieldType(1), SceneFieldType::Short);
     CORRADE_COMPARE(scene.fieldArraySize(1), 0);
-    CORRADE_COMPARE_AS(scene.objectsAsArray(1), Containers::arrayView<UnsignedInt>({
+    CORRADE_COMPARE_AS(scene.mappingAsArray(1), Containers::arrayView<UnsignedInt>({
         33, 25
     }), TestSuite::Compare::Container);
     CORRADE_COMPARE_AS(scene.field<Short>(1),
-        Containers::arrayView(parents),
+        Containers::arrayView(parentData),
         TestSuite::Compare::Container);
 
     CORRADE_COMPARE(scene.fieldName(2), SceneField::Translation);
     CORRADE_COMPARE(scene.fieldType(2), SceneFieldType::Vector2d);
     CORRADE_COMPARE(scene.fieldArraySize(2), 0);
-    CORRADE_COMPARE_AS(scene.objectsAsArray(2),
+    CORRADE_COMPARE_AS(scene.mappingAsArray(2),
         Containers::arrayView<UnsignedInt>({16}),
         TestSuite::Compare::Container);
     CORRADE_COMPARE_AS(scene.field<Vector2d>(2),
-        Containers::arrayView(translations),
+        Containers::arrayView(translationFieldData),
         TestSuite::Compare::Container);
 
     CORRADE_COMPARE(scene.fieldName(3), sceneFieldCustom(15));
     CORRADE_COMPARE(scene.fieldType(3), SceneFieldType::Int);
     CORRADE_COMPARE(scene.fieldArraySize(3), 2);
-    CORRADE_COMPARE_AS(scene.objectsAsArray(3),
+    CORRADE_COMPARE_AS(scene.mappingAsArray(3),
         Containers::arrayView<UnsignedInt>({15, 23}),
         TestSuite::Compare::Container);
     /** @todo clean up once it's possible to compare multidimensional
         containers */
     CORRADE_COMPARE_AS(scene.field<Int[]>(3)[0],
-        (Containers::StridedArrayView2D<const Int>{foos, {2, 2}})[0],
+        (Containers::StridedArrayView2D<const Int>{fooFieldData, {2, 2}})[0],
         TestSuite::Compare::Container);
     CORRADE_COMPARE_AS(scene.field<Int[]>(3)[1],
-        (Containers::StridedArrayView2D<const Int>{foos, {2, 2}})[1],
+        (Containers::StridedArrayView2D<const Int>{fooFieldData, {2, 2}})[1],
         TestSuite::Compare::Container);
 
     CORRADE_COMPARE(scene.fieldName(4), SceneField::Camera);
@@ -165,33 +165,33 @@ void SceneToolsTest::combine() {
 }
 
 void SceneToolsTest::combineAlignment() {
-    const UnsignedShort meshObjects[]{15, 23, 47};
-    const UnsignedByte meshes[]{0, 1, 2};
-    const UnsignedShort translationObjects[]{5}; /* 1 byte padding before */
-    const Vector2d translations[]{{1.5, 3.0}}; /* 4 byte padding before */
-
-    SceneData scene = Implementation::sceneCombine(SceneObjectType::UnsignedShort, 167, Containers::arrayView({
-        SceneFieldData{SceneField::Mesh, Containers::arrayView(meshObjects), Containers::arrayView(meshes)},
-        SceneFieldData{SceneField::Translation, Containers::arrayView(translationObjects), Containers::arrayView(translations)}
+    const UnsignedShort meshMappingData[]{15, 23, 47};
+    const UnsignedByte meshFieldData[]{0, 1, 2};
+    const UnsignedShort translationMappingData[]{5}; /* 1 byte padding before */
+    const Vector2d translationFieldData[]{{1.5, 3.0}}; /* 4 byte padding before */
+
+    SceneData scene = Implementation::sceneCombine(SceneMappingType::UnsignedShort, 167, Containers::arrayView({
+        SceneFieldData{SceneField::Mesh, Containers::arrayView(meshMappingData), Containers::arrayView(meshFieldData)},
+        SceneFieldData{SceneField::Translation, Containers::arrayView(translationMappingData), Containers::arrayView(translationFieldData)}
     }));
 
     CORRADE_COMPARE(scene.dataFlags(), DataFlag::Owned|DataFlag::Mutable);
-    CORRADE_COMPARE(scene.objectType(), SceneObjectType::UnsignedShort);
-    CORRADE_COMPARE(scene.objectCount(), 167);
+    CORRADE_COMPARE(scene.mappingType(), SceneMappingType::UnsignedShort);
+    CORRADE_COMPARE(scene.mappingBound(), 167);
     CORRADE_COMPARE(scene.fieldCount(), 2);
 
     CORRADE_COMPARE(scene.fieldName(0), SceneField::Mesh);
     CORRADE_COMPARE(scene.fieldType(0), SceneFieldType::UnsignedByte);
     CORRADE_COMPARE(scene.fieldArraySize(0), 0);
-    CORRADE_COMPARE_AS(scene.objects<UnsignedShort>(0),
-        Containers::arrayView(meshObjects),
+    CORRADE_COMPARE_AS(scene.mapping<UnsignedShort>(0),
+        Containers::arrayView(meshMappingData),
         TestSuite::Compare::Container);
     CORRADE_COMPARE_AS(scene.field<UnsignedByte>(0),
-        Containers::arrayView(meshes),
+        Containers::arrayView(meshFieldData),
         TestSuite::Compare::Container);
-    CORRADE_COMPARE_AS(reinterpret_cast<std::ptrdiff_t>(scene.objects(0).data()), 2, TestSuite::Compare::Divisible);
-    CORRADE_COMPARE(scene.objects(0).data(), scene.data());
-    CORRADE_COMPARE(scene.objects(0).stride()[0], 2);
+    CORRADE_COMPARE_AS(reinterpret_cast<std::ptrdiff_t>(scene.mapping(0).data()), 2, TestSuite::Compare::Divisible);
+    CORRADE_COMPARE(scene.mapping(0).data(), scene.data());
+    CORRADE_COMPARE(scene.mapping(0).stride()[0], 2);
     CORRADE_COMPARE_AS(reinterpret_cast<std::ptrdiff_t>(scene.field(0).data()), 1, TestSuite::Compare::Divisible);
     CORRADE_COMPARE(scene.field(0).data(), scene.data() + 3*2);
     CORRADE_COMPARE(scene.field(0).stride()[0], 1);
@@ -199,60 +199,60 @@ void SceneToolsTest::combineAlignment() {
     CORRADE_COMPARE(scene.fieldName(1), SceneField::Translation);
     CORRADE_COMPARE(scene.fieldType(1), SceneFieldType::Vector2d);
     CORRADE_COMPARE(scene.fieldArraySize(1), 0);
-    CORRADE_COMPARE_AS(scene.objects<UnsignedShort>(1),
-        Containers::arrayView(translationObjects),
+    CORRADE_COMPARE_AS(scene.mapping<UnsignedShort>(1),
+        Containers::arrayView(translationMappingData),
         TestSuite::Compare::Container);
     CORRADE_COMPARE_AS(scene.field<Vector2d>(1),
-        Containers::arrayView(translations),
+        Containers::arrayView(translationFieldData),
         TestSuite::Compare::Container);
-    CORRADE_COMPARE_AS(reinterpret_cast<std::ptrdiff_t>(scene.objects(1).data()), 2, TestSuite::Compare::Divisible);
-    CORRADE_COMPARE(scene.objects(1).data(), scene.data() + 3*2 + 3 + 1);
-    CORRADE_COMPARE(scene.objects(1).stride()[0], 2);
+    CORRADE_COMPARE_AS(reinterpret_cast<std::ptrdiff_t>(scene.mapping(1).data()), 2, TestSuite::Compare::Divisible);
+    CORRADE_COMPARE(scene.mapping(1).data(), scene.data() + 3*2 + 3 + 1);
+    CORRADE_COMPARE(scene.mapping(1).stride()[0], 2);
     CORRADE_COMPARE_AS(reinterpret_cast<std::ptrdiff_t>(scene.field(1).data()), 8, TestSuite::Compare::Divisible);
     CORRADE_COMPARE(scene.field(1).data(), scene.data() + 3*2 + 3 + 1 + 2 + 4);
     CORRADE_COMPARE(scene.field(1).stride()[0], 16);
 }
 
 void SceneToolsTest::combineObjectsShared() {
-    const UnsignedShort meshObjects[]{15, 23, 47};
-    const UnsignedByte meshes[]{0, 1, 2};
-    const Int meshMaterials[]{72, -1, 23};
+    const UnsignedShort meshMappingData[]{15, 23, 47};
+    const UnsignedByte meshFieldData[]{0, 1, 2};
+    const Int meshMaterialFieldData[]{72, -1, 23};
 
-    const UnsignedShort translationRotationObjects[]{14, 22};
-    const Vector2 translations[]{{-1.0f, 25.3f}, {2.2f, 2.1f}};
-    const Complex rotations[]{Complex::rotation(35.0_degf), Complex::rotation(22.5_degf)};
+    const UnsignedShort translationRotationMappingData[]{14, 22};
+    const Vector2 translationFieldData[]{{-1.0f, 25.3f}, {2.2f, 2.1f}};
+    const Complex rotationFieldData[]{Complex::rotation(35.0_degf), Complex::rotation(22.5_degf)};
 
-    SceneData scene = Implementation::sceneCombine(SceneObjectType::UnsignedInt, 173, Containers::arrayView({
+    SceneData scene = Implementation::sceneCombine(SceneMappingType::UnsignedInt, 173, Containers::arrayView({
         /* Deliberately in an arbitrary order to avoid false assumptions like
            fields sharing the same object mapping always being after each
            other */
-        SceneFieldData{SceneField::Mesh, Containers::arrayView(meshObjects), Containers::arrayView(meshes)},
-        SceneFieldData{SceneField::Translation, Containers::arrayView(translationRotationObjects), Containers::arrayView(translations)},
-        SceneFieldData{SceneField::MeshMaterial, Containers::arrayView(meshObjects), Containers::arrayView(meshMaterials)},
-        SceneFieldData{SceneField::Rotation, Containers::arrayView(translationRotationObjects), Containers::arrayView(rotations)}
+        SceneFieldData{SceneField::Mesh, Containers::arrayView(meshMappingData), Containers::arrayView(meshFieldData)},
+        SceneFieldData{SceneField::Translation, Containers::arrayView(translationRotationMappingData), Containers::arrayView(translationFieldData)},
+        SceneFieldData{SceneField::MeshMaterial, Containers::arrayView(meshMappingData), Containers::arrayView(meshMaterialFieldData)},
+        SceneFieldData{SceneField::Rotation, Containers::arrayView(translationRotationMappingData), Containers::arrayView(rotationFieldData)}
     }));
 
     CORRADE_COMPARE(scene.dataFlags(), DataFlag::Owned|DataFlag::Mutable);
-    CORRADE_COMPARE(scene.objectType(), SceneObjectType::UnsignedInt);
-    CORRADE_COMPARE(scene.objectCount(), 173);
+    CORRADE_COMPARE(scene.mappingType(), SceneMappingType::UnsignedInt);
+    CORRADE_COMPARE(scene.mappingBound(), 173);
     CORRADE_COMPARE(scene.fieldCount(), 4);
 
     CORRADE_COMPARE(scene.fieldSize(SceneField::Mesh), 3);
     CORRADE_COMPARE(scene.fieldSize(SceneField::MeshMaterial), 3);
-    CORRADE_COMPARE(scene.objects(SceneField::Mesh).data(), scene.objects(SceneField::MeshMaterial).data());
+    CORRADE_COMPARE(scene.mapping(SceneField::Mesh).data(), scene.mapping(SceneField::MeshMaterial).data());
 
     CORRADE_COMPARE(scene.fieldSize(SceneField::Translation), 2);
     CORRADE_COMPARE(scene.fieldSize(SceneField::Rotation), 2);
-    CORRADE_COMPARE(scene.objects(SceneField::Translation).data(), scene.objects(SceneField::Rotation).data());
+    CORRADE_COMPARE(scene.mapping(SceneField::Translation).data(), scene.mapping(SceneField::Rotation).data());
 }
 
 void SceneToolsTest::combineObjectsPlaceholderFieldPlaceholder() {
-    const UnsignedShort meshObjects[]{15, 23, 47};
-    const UnsignedByte meshes[]{0, 1, 2};
+    const UnsignedShort meshMappingData[]{15, 23, 47};
+    const UnsignedByte meshFieldData[]{0, 1, 2};
 
-    SceneData scene = Implementation::sceneCombine(SceneObjectType::UnsignedShort, 173, Containers::arrayView({
+    SceneData scene = Implementation::sceneCombine(SceneMappingType::UnsignedShort, 173, Containers::arrayView({
         SceneFieldData{SceneField::Camera, Containers::ArrayView<UnsignedByte>{nullptr, 1}, Containers::ArrayView<UnsignedShort>{nullptr, 1}},
-        SceneFieldData{SceneField::Mesh, Containers::arrayView(meshObjects), Containers::arrayView(meshes)},
+        SceneFieldData{SceneField::Mesh, Containers::arrayView(meshMappingData), Containers::arrayView(meshFieldData)},
         /* Looks like sharing object mapping with the Camera field, but
            actually both are placeholders */
         SceneFieldData{SceneField::Light, Containers::ArrayView<UnsignedShort>{nullptr, 2}, Containers::ArrayView<UnsignedInt>{nullptr, 2}},
@@ -261,73 +261,73 @@ void SceneToolsTest::combineObjectsPlaceholderFieldPlaceholder() {
     }));
 
     CORRADE_COMPARE(scene.dataFlags(), DataFlag::Owned|DataFlag::Mutable);
-    CORRADE_COMPARE(scene.objectType(), SceneObjectType::UnsignedShort);
-    CORRADE_COMPARE(scene.objectCount(), 173);
+    CORRADE_COMPARE(scene.mappingType(), SceneMappingType::UnsignedShort);
+    CORRADE_COMPARE(scene.mappingBound(), 173);
     CORRADE_COMPARE(scene.fieldCount(), 4);
 
     CORRADE_COMPARE(scene.fieldType(SceneField::Camera), SceneFieldType::UnsignedShort);
     CORRADE_COMPARE(scene.fieldSize(SceneField::Camera), 1);
     CORRADE_COMPARE(scene.fieldArraySize(SceneField::Camera), 0);
-    CORRADE_COMPARE(scene.objects(SceneField::Camera).data(), scene.data());
-    CORRADE_COMPARE(scene.objects(SceneField::Camera).stride()[0], 2);
+    CORRADE_COMPARE(scene.mapping(SceneField::Camera).data(), scene.data());
+    CORRADE_COMPARE(scene.mapping(SceneField::Camera).stride()[0], 2);
     CORRADE_COMPARE(scene.field(SceneField::Camera).data(), scene.data() + 2);
     CORRADE_COMPARE(scene.field(SceneField::Camera).stride()[0], 2);
 
     CORRADE_COMPARE(scene.fieldType(SceneField::Mesh), SceneFieldType::UnsignedByte);
     CORRADE_COMPARE(scene.fieldArraySize(SceneField::Mesh), 0);
-    CORRADE_COMPARE_AS(scene.objects<UnsignedShort>(SceneField::Mesh),
-        Containers::arrayView(meshObjects),
+    CORRADE_COMPARE_AS(scene.mapping<UnsignedShort>(SceneField::Mesh),
+        Containers::arrayView(meshMappingData),
         TestSuite::Compare::Container);
     CORRADE_COMPARE_AS(scene.field<UnsignedByte>(SceneField::Mesh),
-        Containers::arrayView(meshes),
+        Containers::arrayView(meshFieldData),
         TestSuite::Compare::Container);
 
     CORRADE_COMPARE(scene.fieldType(SceneField::Light), SceneFieldType::UnsignedInt);
     CORRADE_COMPARE(scene.fieldSize(SceneField::Light), 2);
     CORRADE_COMPARE(scene.fieldArraySize(SceneField::Light), 0);
-    CORRADE_COMPARE(scene.objects(SceneField::Light).data(), scene.data() + 2 + 2 + 3*2 + 3 + 1);
-    CORRADE_COMPARE(scene.objects(SceneField::Light).stride()[0], 2);
+    CORRADE_COMPARE(scene.mapping(SceneField::Light).data(), scene.data() + 2 + 2 + 3*2 + 3 + 1);
+    CORRADE_COMPARE(scene.mapping(SceneField::Light).stride()[0], 2);
     CORRADE_COMPARE(scene.field(SceneField::Light).data(), scene.data() + 2 + 2 + 3*2 + 3 + 1 + 2*2 + 2);
     CORRADE_COMPARE(scene.field(SceneField::Light).stride()[0], 4);
 
     CORRADE_COMPARE(scene.fieldType(sceneFieldCustom(15)), SceneFieldType::Short);
     CORRADE_COMPARE(scene.fieldSize(sceneFieldCustom(15)), 2);
     CORRADE_COMPARE(scene.fieldArraySize(sceneFieldCustom(15)), 4);
-    CORRADE_COMPARE(scene.objects(sceneFieldCustom(15)).data(), scene.data() + 2 + 2 + 3*2 + 3 + 1 + 2*2 + 2 + 2*4);
-    CORRADE_COMPARE(scene.objects(sceneFieldCustom(15)).stride()[0], 2);
+    CORRADE_COMPARE(scene.mapping(sceneFieldCustom(15)).data(), scene.data() + 2 + 2 + 3*2 + 3 + 1 + 2*2 + 2 + 2*4);
+    CORRADE_COMPARE(scene.mapping(sceneFieldCustom(15)).stride()[0], 2);
     CORRADE_COMPARE(scene.field(sceneFieldCustom(15)).data(), scene.data() + 2 + 2 + 3*2 + 3 + 1 + 2*2 + 2 + 2*4 + 2*2);
     CORRADE_COMPARE(scene.field(sceneFieldCustom(15)).stride()[0], 4*2);
 }
 
 void SceneToolsTest::combineObjectSharedFieldPlaceholder() {
-    const UnsignedInt meshObjects[]{15, 23, 47};
-    const UnsignedByte meshes[]{0, 1, 2};
+    const UnsignedInt meshMappingData[]{15, 23, 47};
+    const UnsignedByte meshFieldData[]{0, 1, 2};
 
-    SceneData scene = Implementation::sceneCombine(SceneObjectType::UnsignedInt, 173, Containers::arrayView({
-        SceneFieldData{SceneField::Mesh, Containers::arrayView(meshObjects), Containers::arrayView(meshes)},
-        SceneFieldData{SceneField::MeshMaterial, Containers::arrayView(meshObjects), Containers::ArrayView<Int>{nullptr, 3}},
+    SceneData scene = Implementation::sceneCombine(SceneMappingType::UnsignedInt, 173, Containers::arrayView({
+        SceneFieldData{SceneField::Mesh, Containers::arrayView(meshMappingData), Containers::arrayView(meshFieldData)},
+        SceneFieldData{SceneField::MeshMaterial, Containers::arrayView(meshMappingData), Containers::ArrayView<Int>{nullptr, 3}},
     }));
 
     CORRADE_COMPARE(scene.dataFlags(), DataFlag::Owned|DataFlag::Mutable);
-    CORRADE_COMPARE(scene.objectType(), SceneObjectType::UnsignedInt);
-    CORRADE_COMPARE(scene.objectCount(), 173);
+    CORRADE_COMPARE(scene.mappingType(), SceneMappingType::UnsignedInt);
+    CORRADE_COMPARE(scene.mappingBound(), 173);
     CORRADE_COMPARE(scene.fieldCount(), 2);
 
     CORRADE_COMPARE(scene.fieldType(SceneField::Mesh), SceneFieldType::UnsignedByte);
     CORRADE_COMPARE(scene.fieldArraySize(SceneField::Mesh), 0);
-    CORRADE_COMPARE_AS(scene.objects<UnsignedInt>(0),
-        Containers::arrayView(meshObjects),
+    CORRADE_COMPARE_AS(scene.mapping<UnsignedInt>(0),
+        Containers::arrayView(meshMappingData),
         TestSuite::Compare::Container);
     CORRADE_COMPARE_AS(scene.field<UnsignedByte>(0),
-        Containers::arrayView(meshes),
+        Containers::arrayView(meshFieldData),
         TestSuite::Compare::Container);
 
     CORRADE_COMPARE(scene.fieldType(SceneField::MeshMaterial), SceneFieldType::Int);
     CORRADE_COMPARE(scene.fieldSize(SceneField::MeshMaterial), 3);
     CORRADE_COMPARE(scene.fieldArraySize(SceneField::MeshMaterial), 0);
-    CORRADE_COMPARE(scene.objects(SceneField::MeshMaterial).data(), scene.objects(SceneField::Mesh).data());
-    CORRADE_COMPARE_AS(scene.objects<UnsignedInt>(SceneField::MeshMaterial),
-        Containers::arrayView(meshObjects),
+    CORRADE_COMPARE(scene.mapping(SceneField::MeshMaterial).data(), scene.mapping(SceneField::Mesh).data());
+    CORRADE_COMPARE_AS(scene.mapping<UnsignedInt>(SceneField::MeshMaterial),
+        Containers::arrayView(meshMappingData),
         TestSuite::Compare::Container);
     CORRADE_COMPARE(scene.field(SceneField::MeshMaterial).data(), scene.data() + 3*4 + 3 + 1);
     CORRADE_COMPARE(scene.field(SceneField::MeshMaterial).stride()[0], 4);
@@ -340,13 +340,13 @@ void SceneToolsTest::convertToSingleFunctionObjects() {
     /* Haha now I can use sceneCombine() to conveniently prepare the initial
        state here, without having to mess with an ArrayTuple */
 
-    const UnsignedShort parentObjects[]{15, 21, 22, 23, 1};
-    const Byte parents[]{-1, -1, 21, 22, -1};
+    const UnsignedShort parentMappingData[]{15, 21, 22, 23, 1};
+    const Byte parentFieldData[]{-1, -1, 21, 22, -1};
 
     /* Two objects have two and three mesh assignments respectively, meaning we
        need three extra */
-    const UnsignedShort meshObjects[]{15, 23, 23, 23, 1, 15, 21};
-    const Containers::Pair<UnsignedInt, Int> meshesMaterials[]{
+    const UnsignedShort meshMappingData[]{15, 23, 23, 23, 1, 15, 21};
+    const Containers::Pair<UnsignedInt, Int> meshMaterialFieldData[]{
         {6, 4},
         {1, 0},
         {2, 3},
@@ -358,13 +358,13 @@ void SceneToolsTest::convertToSingleFunctionObjects() {
 
     /* One camera is attached to an object that already has a mesh, meaning we
        need a third extra object */
-    const UnsignedShort cameraObjects[]{22, 1};
-    const UnsignedInt cameras[]{1, 5};
-    SceneData original = Implementation::sceneCombine(SceneObjectType::UnsignedShort, data.originalObjectCount, Containers::arrayView({
-        SceneFieldData{SceneField::Parent, Containers::arrayView(parentObjects), Containers::arrayView(parents)},
-        SceneFieldData{SceneField::Mesh, Containers::arrayView(meshObjects), Containers::StridedArrayView1D<const UnsignedInt>{meshesMaterials, &meshesMaterials[0].first(), Containers::arraySize(meshesMaterials), sizeof(meshesMaterials[0])}},
-        SceneFieldData{SceneField::MeshMaterial, Containers::arrayView(meshObjects), Containers::StridedArrayView1D<const Int>{meshesMaterials, &meshesMaterials[0].second(), Containers::arraySize(meshesMaterials), sizeof(meshesMaterials[0])}},
-        SceneFieldData{SceneField::Camera, Containers::arrayView(cameraObjects), Containers::arrayView(cameras)},
+    const UnsignedShort cameraMappingData[]{22, 1};
+    const UnsignedInt cameraFieldData[]{1, 5};
+    SceneData original = Implementation::sceneCombine(SceneMappingType::UnsignedShort, data.originalObjectCount, Containers::arrayView({
+        SceneFieldData{SceneField::Parent, Containers::arrayView(parentMappingData), Containers::arrayView(parentFieldData)},
+        SceneFieldData{SceneField::Mesh, Containers::arrayView(meshMappingData), Containers::StridedArrayView1D<const UnsignedInt>{meshMaterialFieldData, &meshMaterialFieldData[0].first(), Containers::arraySize(meshMaterialFieldData), sizeof(meshMaterialFieldData[0])}},
+        SceneFieldData{SceneField::MeshMaterial, Containers::arrayView(meshMappingData), Containers::StridedArrayView1D<const Int>{meshMaterialFieldData, &meshMaterialFieldData[0].second(), Containers::arraySize(meshMaterialFieldData), sizeof(meshMaterialFieldData[0])}},
+        SceneFieldData{SceneField::Camera, Containers::arrayView(cameraMappingData), Containers::arrayView(cameraFieldData)},
     }));
 
     SceneData scene = Implementation::sceneConvertToSingleFunctionObjects(original, Containers::arrayView({
@@ -379,7 +379,7 @@ void SceneToolsTest::convertToSingleFunctionObjects() {
 
     /* There should be three more objects, or the original count preserved if
        it's large enough */
-    CORRADE_COMPARE(scene.objectCount(), data.expectedObjectCount);
+    CORRADE_COMPARE(scene.mappingBound(), data.expectedObjectCount);
 
     /* Object 1 should have a new child that has the camera, as it has a mesh */
     CORRADE_COMPARE_AS(scene.childrenFor(1),
diff --git a/src/Magnum/Trade/Trade.h b/src/Magnum/Trade/Trade.h
index fdd47b9c7..af0411e4a 100644
--- a/src/Magnum/Trade/Trade.h
+++ b/src/Magnum/Trade/Trade.h
@@ -100,7 +100,7 @@ class PbrSpecularGlossinessMaterialData;
 class PhongMaterialData;
 class TextureData;
 
-enum class SceneObjectType: UnsignedByte;
+enum class SceneMappingType: UnsignedByte;
 enum class SceneField: UnsignedInt;
 enum class SceneFieldType: UnsignedShort;
 class SceneFieldData;