/*
    This file is part of Magnum.

    Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019,
                2020, 2021 Vladimír Vondruš <mosra@centrum.cz>

    Permission is hereby granted, free of charge, to any person obtaining a
    copy of this software and associated documentation files (the "Software"),
    to deal in the Software without restriction, including without limitation
    the rights to use, copy, modify, merge, publish, distribute, sublicense,
    and/or sell copies of the Software, and to permit persons to whom the
    Software is furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be included
    in all copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
    DEALINGS IN THE SOFTWARE.
*/

#include "SceneData.h"

#include <Corrade/Containers/GrowableArray.h>
#include <Corrade/Containers/Optional.h>
#include <Corrade/Containers/Pair.h>
#include <Corrade/Containers/Triple.h>
#include <Corrade/Utility/Algorithms.h>

#include "Magnum/Math/FunctionsBatch.h"
#include "Magnum/Math/Matrix3.h"
#include "Magnum/Math/Matrix4.h"
#include "Magnum/Math/DualComplex.h"
#include "Magnum/Math/DualQuaternion.h"
#include "Magnum/Math/PackingBatch.h"
#include "Magnum/Trade/Implementation/arrayUtilities.h"

#ifdef MAGNUM_BUILD_DEPRECATED
#include <vector>
#include <Corrade/Containers/ArrayTuple.h>
#include <Corrade/Containers/ArrayViewStl.h>
#endif

namespace Magnum { namespace Trade {

Debug& operator<<(Debug& debug, const SceneObjectType value) {
    debug << "Trade::SceneObjectType" << Debug::nospace;

    switch(value) {
        /* LCOV_EXCL_START */
        #define _c(value) case SceneObjectType::value: return debug << "::" #value;
        _c(UnsignedByte)
        _c(UnsignedInt)
        _c(UnsignedShort)
        _c(UnsignedLong)
        #undef _c
        /* LCOV_EXCL_STOP */
    }

    return debug << "(" << Debug::nospace << reinterpret_cast<void*>(UnsignedByte(value)) << Debug::nospace << ")";
}

UnsignedInt sceneObjectTypeSize(const SceneObjectType 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;
    }
    #ifdef CORRADE_TARGET_GCC
    #pragma GCC diagnostic pop
    #endif

    CORRADE_ASSERT_UNREACHABLE("Trade::sceneObjectTypeSize(): invalid type" << type, {});
}

UnsignedInt sceneObjectTypeAlignment(const SceneObjectType 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;
    }
    #ifdef CORRADE_TARGET_GCC
    #pragma GCC diagnostic pop
    #endif

    CORRADE_ASSERT_UNREACHABLE("Trade::sceneObjectTypeAlignment(): invalid type" << type, {});
}

Debug& operator<<(Debug& debug, const SceneField value) {
    debug << "Trade::SceneField" << Debug::nospace;

    if(UnsignedInt(value) >= UnsignedInt(SceneField::Custom))
        return debug << "::Custom(" << Debug::nospace << (UnsignedInt(value) - UnsignedInt(SceneField::Custom)) << Debug::nospace << ")";

    switch(value) {
        /* LCOV_EXCL_START */
        #define _c(value) case SceneField::value: return debug << "::" #value;
        _c(Parent)
        _c(Transformation)
        _c(Translation)
        _c(Rotation)
        _c(Scaling)
        _c(Mesh)
        _c(MeshMaterial)
        _c(Light)
        _c(Camera)
        _c(Skin)
        _c(ImporterState)
        #undef _c
        /* LCOV_EXCL_STOP */

        /* To silence compiler warning about unhandled values */
        case SceneField::Custom: CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
    }

    return debug << "(" << Debug::nospace << reinterpret_cast<void*>(UnsignedInt(value)) << Debug::nospace << ")";
}

Debug& operator<<(Debug& debug, const SceneFieldType value) {
    debug << "Trade::SceneFieldType" << Debug::nospace;

    switch(value) {
        /* LCOV_EXCL_START */
        #define _c(value) case SceneFieldType::value: return debug << "::" #value;
        _c(Float)
        _c(Half)
        _c(Double)
        _c(UnsignedByte)
        _c(Byte)
        _c(UnsignedShort)
        _c(Short)
        _c(UnsignedInt)
        _c(Int)
        _c(UnsignedLong)
        _c(Long)
        _c(Vector2)
        _c(Vector2h)
        _c(Vector2d)
        _c(Vector2ub)
        _c(Vector2b)
        _c(Vector2us)
        _c(Vector2s)
        _c(Vector2ui)
        _c(Vector2i)
        _c(Vector3)
        _c(Vector3h)
        _c(Vector3d)
        _c(Vector3ub)
        _c(Vector3b)
        _c(Vector3us)
        _c(Vector3s)
        _c(Vector3ui)
        _c(Vector3i)
        _c(Vector4)
        _c(Vector4h)
        _c(Vector4d)
        _c(Vector4ub)
        _c(Vector4b)
        _c(Vector4us)
        _c(Vector4s)
        _c(Vector4ui)
        _c(Vector4i)
        _c(Matrix2x2)
        _c(Matrix2x2h)
        _c(Matrix2x2d)
        _c(Matrix2x3)
        _c(Matrix2x3h)
        _c(Matrix2x3d)
        _c(Matrix2x4)
        _c(Matrix2x4h)
        _c(Matrix2x4d)
        _c(Matrix3x2)
        _c(Matrix3x2h)
        _c(Matrix3x2d)
        _c(Matrix3x3)
        _c(Matrix3x3h)
        _c(Matrix3x3d)
        _c(Matrix3x4)
        _c(Matrix3x4h)
        _c(Matrix3x4d)
        _c(Matrix4x2)
        _c(Matrix4x2h)
        _c(Matrix4x2d)
        _c(Matrix4x3)
        _c(Matrix4x3h)
        _c(Matrix4x3d)
        _c(Matrix4x4)
        _c(Matrix4x4h)
        _c(Matrix4x4d)
        _c(Range1D)
        _c(Range1Dh)
        _c(Range1Dd)
        _c(Range1Di)
        _c(Range2D)
        _c(Range2Dh)
        _c(Range2Dd)
        _c(Range2Di)
        _c(Range3D)
        _c(Range3Dh)
        _c(Range3Dd)
        _c(Range3Di)
        _c(Complex)
        _c(Complexd)
        _c(DualComplex)
        _c(DualComplexd)
        _c(Quaternion)
        _c(Quaterniond)
        _c(DualQuaternion)
        _c(DualQuaterniond)
        _c(Deg)
        _c(Degh)
        _c(Degd)
        _c(Rad)
        _c(Radh)
        _c(Radd)
        _c(Pointer)
        _c(MutablePointer)
        #undef _c
        /* LCOV_EXCL_STOP */
    }

    return debug << "(" << Debug::nospace << reinterpret_cast<void*>(UnsignedShort(value)) << Debug::nospace << ")";
}

UnsignedInt sceneFieldTypeSize(const SceneFieldType type) {
    #ifdef CORRADE_TARGET_GCC
    #pragma GCC diagnostic push
    #pragma GCC diagnostic error "-Wswitch"
    #endif
    switch(type) {
        case SceneFieldType::UnsignedByte:
        case SceneFieldType::Byte:
            return 1;
        case SceneFieldType::UnsignedShort:
        case SceneFieldType::Short:
        case SceneFieldType::Half:
        case SceneFieldType::Vector2ub:
        case SceneFieldType::Vector2b:
        case SceneFieldType::Degh:
        case SceneFieldType::Radh:
            return 2;
        case SceneFieldType::Vector3ub:
        case SceneFieldType::Vector3b:
            return 3;
        case SceneFieldType::UnsignedInt:
        case SceneFieldType::Int:
        case SceneFieldType::Float:
        case SceneFieldType::Vector2us:
        case SceneFieldType::Vector2s:
        case SceneFieldType::Vector2h:
        case SceneFieldType::Vector4ub:
        case SceneFieldType::Vector4b:
        case SceneFieldType::Range1Dh:
        case SceneFieldType::Deg:
        case SceneFieldType::Rad:
            return 4;
        case SceneFieldType::Vector3us:
        case SceneFieldType::Vector3s:
        case SceneFieldType::Vector3h:
            return 6;
        case SceneFieldType::UnsignedLong:
        case SceneFieldType::Long:
        case SceneFieldType::Double:
        case SceneFieldType::Vector2:
        case SceneFieldType::Vector2ui:
        case SceneFieldType::Vector2i:
        case SceneFieldType::Vector4us:
        case SceneFieldType::Vector4s:
        case SceneFieldType::Vector4h:
        case SceneFieldType::Matrix2x2h:
        case SceneFieldType::Range1D:
        case SceneFieldType::Range1Di:
        case SceneFieldType::Range2Dh:
        case SceneFieldType::Complex:
        case SceneFieldType::Degd:
        case SceneFieldType::Radd:
            return 8;
        case SceneFieldType::Vector3:
        case SceneFieldType::Vector3ui:
        case SceneFieldType::Vector3i:
        case SceneFieldType::Matrix2x3h:
        case SceneFieldType::Matrix3x2h:
        case SceneFieldType::Range3Dh:
            return 12;
        case SceneFieldType::Vector2d:
        case SceneFieldType::Vector4:
        case SceneFieldType::Vector4ui:
        case SceneFieldType::Vector4i:
        case SceneFieldType::Matrix2x2:
        case SceneFieldType::Matrix2x4h:
        case SceneFieldType::Matrix4x2h:
        case SceneFieldType::Range1Dd:
        case SceneFieldType::Range2D:
        case SceneFieldType::Range2Di:
        case SceneFieldType::Complexd:
        case SceneFieldType::DualComplex:
        case SceneFieldType::Quaternion:
            return 16;
        case SceneFieldType::Matrix3x3h:
            return 18;
        case SceneFieldType::Vector3d:
        case SceneFieldType::Matrix2x3:
        case SceneFieldType::Matrix3x4h:
        case SceneFieldType::Matrix3x2:
        case SceneFieldType::Matrix4x3h:
        case SceneFieldType::Range3D:
        case SceneFieldType::Range3Di:
            return 24;
        case SceneFieldType::Vector4d:
        case SceneFieldType::Matrix2x2d:
        case SceneFieldType::Matrix2x4:
        case SceneFieldType::Matrix4x2:
        case SceneFieldType::Matrix4x4h:
        case SceneFieldType::Range2Dd:
        case SceneFieldType::DualComplexd:
        case SceneFieldType::Quaterniond:
        case SceneFieldType::DualQuaternion:
            return 32;
        case SceneFieldType::Matrix3x3:
            return 36;
        case SceneFieldType::Matrix2x3d:
        case SceneFieldType::Matrix3x4:
        case SceneFieldType::Matrix3x2d:
        case SceneFieldType::Matrix4x3:
        case SceneFieldType::Range3Dd:
            return 48;
        case SceneFieldType::Matrix2x4d:
        case SceneFieldType::Matrix4x2d:
        case SceneFieldType::Matrix4x4:
        case SceneFieldType::DualQuaterniond:
            return 64;
        case SceneFieldType::Matrix3x3d:
            return 72;
        case SceneFieldType::Matrix3x4d:
        case SceneFieldType::Matrix4x3d:
            return 96;
        case SceneFieldType::Matrix4x4d:
            return 128;
        case SceneFieldType::Pointer:
        case SceneFieldType::MutablePointer:
            return sizeof(void*);
    }
    #ifdef CORRADE_TARGET_GCC
    #pragma GCC diagnostic pop
    #endif

    CORRADE_ASSERT_UNREACHABLE("Trade::sceneFieldTypeSize(): invalid type" << type, {});
}

UnsignedInt sceneFieldTypeAlignment(const SceneFieldType type) {
    #ifdef CORRADE_TARGET_GCC
    #pragma GCC diagnostic push
    #pragma GCC diagnostic error "-Wswitch"
    #endif
    switch(type) {
        case SceneFieldType::UnsignedByte:
        case SceneFieldType::Vector2ub:
        case SceneFieldType::Vector3ub:
        case SceneFieldType::Vector4ub:
        case SceneFieldType::Byte:
        case SceneFieldType::Vector2b:
        case SceneFieldType::Vector3b:
        case SceneFieldType::Vector4b:
            return 1;
        case SceneFieldType::UnsignedShort:
        case SceneFieldType::Vector2us:
        case SceneFieldType::Vector3us:
        case SceneFieldType::Vector4us:
        case SceneFieldType::Short:
        case SceneFieldType::Vector2s:
        case SceneFieldType::Vector3s:
        case SceneFieldType::Vector4s:
        case SceneFieldType::Half:
        case SceneFieldType::Vector2h:
        case SceneFieldType::Vector3h:
        case SceneFieldType::Vector4h:
        case SceneFieldType::Matrix2x2h:
        case SceneFieldType::Matrix2x3h:
        case SceneFieldType::Matrix2x4h:
        case SceneFieldType::Matrix3x2h:
        case SceneFieldType::Matrix3x3h:
        case SceneFieldType::Matrix3x4h:
        case SceneFieldType::Matrix4x2h:
        case SceneFieldType::Matrix4x3h:
        case SceneFieldType::Matrix4x4h:
        case SceneFieldType::Range1Dh:
        case SceneFieldType::Range2Dh:
        case SceneFieldType::Range3Dh:
        case SceneFieldType::Degh:
        case SceneFieldType::Radh:
            return 2;
        case SceneFieldType::UnsignedInt:
        case SceneFieldType::Vector2ui:
        case SceneFieldType::Vector3ui:
        case SceneFieldType::Vector4ui:
        case SceneFieldType::Int:
        case SceneFieldType::Vector2i:
        case SceneFieldType::Vector3i:
        case SceneFieldType::Vector4i:
        case SceneFieldType::Float:
        case SceneFieldType::Vector2:
        case SceneFieldType::Vector3:
        case SceneFieldType::Vector4:
        case SceneFieldType::Matrix2x2:
        case SceneFieldType::Matrix2x3:
        case SceneFieldType::Matrix2x4:
        case SceneFieldType::Matrix3x2:
        case SceneFieldType::Matrix3x3:
        case SceneFieldType::Matrix3x4:
        case SceneFieldType::Matrix4x2:
        case SceneFieldType::Matrix4x3:
        case SceneFieldType::Matrix4x4:
        case SceneFieldType::Range1Di:
        case SceneFieldType::Range2Di:
        case SceneFieldType::Range3Di:
        case SceneFieldType::Range1D:
        case SceneFieldType::Range2D:
        case SceneFieldType::Range3D:
        case SceneFieldType::Complex:
        case SceneFieldType::Quaternion:
        case SceneFieldType::DualComplex:
        case SceneFieldType::DualQuaternion:
        case SceneFieldType::Deg:
        case SceneFieldType::Rad:
            return 4;
        case SceneFieldType::UnsignedLong:
        case SceneFieldType::Long:
        case SceneFieldType::Double:
        case SceneFieldType::Vector2d:
        case SceneFieldType::Vector3d:
        case SceneFieldType::Vector4d:
        case SceneFieldType::Matrix2x2d:
        case SceneFieldType::Matrix2x3d:
        case SceneFieldType::Matrix2x4d:
        case SceneFieldType::Matrix3x2d:
        case SceneFieldType::Matrix3x3d:
        case SceneFieldType::Matrix3x4d:
        case SceneFieldType::Matrix4x2d:
        case SceneFieldType::Matrix4x3d:
        case SceneFieldType::Matrix4x4d:
        case SceneFieldType::Range1Dd:
        case SceneFieldType::Range2Dd:
        case SceneFieldType::Range3Dd:
        case SceneFieldType::Complexd:
        case SceneFieldType::Quaterniond:
        case SceneFieldType::DualComplexd:
        case SceneFieldType::DualQuaterniond:
        case SceneFieldType::Degd:
        case SceneFieldType::Radd:
            return 8;
        case SceneFieldType::Pointer:
        case SceneFieldType::MutablePointer:
            return sizeof(void*);
    }
    #ifdef CORRADE_TARGET_GCC
    #pragma GCC diagnostic pop
    #endif

    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} {
    /* Yes, this calls into a constexpr function defined in the header --
       because I feel that makes more sense than duplicating the full assert
       logic */
    #ifndef CORRADE_NO_ASSERT
    if(fieldArraySize) CORRADE_ASSERT(fieldData.empty()[0] || fieldData.size()[1] == sceneFieldTypeSize(fieldType)*fieldArraySize,
        "Trade::SceneFieldData: second field view dimension size" << fieldData.size()[1] << "doesn't match" << fieldType << "and field array size" << fieldArraySize, );
    else CORRADE_ASSERT(fieldData.empty()[0] || fieldData.size()[1] == sceneFieldTypeSize(fieldType),
        "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], );

    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) {
    /* Ugly, eh? */
    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 */
    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", );

    #ifndef CORRADE_NO_ASSERT
    /* Check various assumptions about field data */
    Math::BoolVector<12> fieldsPresent; /** @todo some constant for this */
    const UnsignedInt objectTypeSize = sceneObjectTypeSize(_objectType);
    #endif
    UnsignedInt transformationField = ~UnsignedInt{};
    UnsignedInt translationField = ~UnsignedInt{};
    UnsignedInt rotationField = ~UnsignedInt{};
    UnsignedInt scalingField = ~UnsignedInt{};
    #ifndef CORRADE_NO_ASSERT
    UnsignedInt meshField = ~UnsignedInt{};
    UnsignedInt meshMaterialField = ~UnsignedInt{};
    UnsignedInt skinField = ~UnsignedInt{};
    #endif
    for(std::size_t i = 0; i != _fields.size(); ++i) {
        const SceneFieldData& field = _fields[i];

        #ifndef CORRADE_NO_ASSERT
        /* The object 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
           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, );

        /* 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,
           as a single object can have multiple instances of the same field
           attached, so checking that would be wrong. */

        /* Check that there are only unique fields. To avoid a O(n^2) operation
           always (or allocating a sorted field map), builtin fields are
           checked against a map and only custom fields are checked in an
           O(n^2) way with the assumption there isn't many of them (and that
           they'll gradually become builtin). */
        if(!isSceneFieldCustom(_fields[i]._name)) {
            CORRADE_INTERNAL_ASSERT(UnsignedInt(_fields[i]._name) < fieldsPresent.Size);
            CORRADE_ASSERT(!fieldsPresent[UnsignedInt(_fields[i]._name)],
                "Trade::SceneData: duplicate field" << _fields[i]._name, );
            fieldsPresent.set(UnsignedInt(_fields[i]._name), true);
        } else for(std::size_t j = 0; j != i; ++j) {
            CORRADE_ASSERT(_fields[j]._name != _fields[i]._name,
                "Trade::SceneData: duplicate field" << _fields[i]._name, );
        }

        /* Check that both the object 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. */
        if(field._size) {
            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 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(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 fieldBegin = field._fieldData.pointer;
                const void* const objectEnd = static_cast<const char*>(field._objectData.pointer) + (field._size - 1)*field._objectStride + objectTypeSize;
                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(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 << "]", );
            }
        }
        #endif

        /* Remember TRS and mesh/material fields to figure out whether the
           scene is 2D or 3D and check their object mapping consistency outside
           of the loop below */
        if(_fields[i]._name == SceneField::Transformation) {
            transformationField = i;
        } else if(_fields[i]._name == SceneField::Translation) {
            translationField = i;
        } else if(_fields[i]._name == SceneField::Rotation) {
            rotationField = i;
        } else if(_fields[i]._name == SceneField::Scaling) {
            scalingField = i;
        }
        #ifndef CORRADE_NO_ASSERT
        else if(_fields[i]._name == SceneField::Mesh) {
            meshField = i;
        } else if(_fields[i]._name == SceneField::MeshMaterial) {
            meshMaterialField = i;
        } else if(_fields[i]._name == SceneField::Skin) {
            skinField = i;
        }
        #endif
    }

    #ifndef CORRADE_NO_ASSERT
    /* Check that certain fields share the same object mapping. Printing as if
       all would be pointers (and not offset-only), it's not worth the extra
       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;
        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 << "]", );
    };

    /* All present TRS fields should share the same object mapping */
    if(translationField != ~UnsignedInt{}) {
        if(rotationField != ~UnsignedInt{})
            checkFieldObjectDataMatch(_fields[translationField], _fields[rotationField]);
        if(scalingField != ~UnsignedInt{})
            checkFieldObjectDataMatch(_fields[translationField], _fields[scalingField]);
    }
    if(rotationField != ~UnsignedInt{} && scalingField != ~UnsignedInt{})
        checkFieldObjectDataMatch(_fields[rotationField], _fields[scalingField]);

    /* Mesh and materials also */
    if(meshField != ~UnsignedInt{} && meshMaterialField != ~UnsignedInt{})
        checkFieldObjectDataMatch(_fields[meshField], _fields[meshMaterialField]);
    #endif

    /* Decide about dimensionality based on transformation type, if present */
    if(transformationField != ~UnsignedInt{}) {
        const SceneFieldType fieldType = _fields[transformationField]._fieldType;
        if(fieldType == SceneFieldType::Matrix3x3 ||
           fieldType == SceneFieldType::Matrix3x3d ||
           fieldType == SceneFieldType::Matrix3x2 ||
           fieldType == SceneFieldType::Matrix3x2d ||
           fieldType == SceneFieldType::DualComplex ||
           fieldType == SceneFieldType::DualComplexd)
            _dimensions = 2;
        else if(fieldType == SceneFieldType::Matrix4x4 ||
                fieldType == SceneFieldType::Matrix4x4d ||
                fieldType == SceneFieldType::Matrix4x3 ||
                fieldType == SceneFieldType::Matrix4x3d ||
                fieldType == SceneFieldType::DualQuaternion ||
                fieldType == SceneFieldType::DualQuaterniond)
            _dimensions = 3;
        else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
    }

    /* Use TRS fields to decide about dimensionality, if the transformation
       field is not present. If it is, verify that they match it. */
    if(translationField != ~UnsignedInt{}) {
        const SceneFieldType fieldType = _fields[translationField]._fieldType;
        if(fieldType == SceneFieldType::Vector2 ||
           fieldType == SceneFieldType::Vector2d) {
            CORRADE_ASSERT(!_dimensions || _dimensions == 2,
                "Trade::SceneData: expected a 3D translation field but got" << fieldType, );
            _dimensions = 2;
        } else if(fieldType == SceneFieldType::Vector3 ||
                  fieldType == SceneFieldType::Vector3d) {
            CORRADE_ASSERT(!_dimensions || _dimensions == 3,
                "Trade::SceneData: expected a 2D translation field but got" << fieldType, );
            _dimensions = 3;
        } else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
    }
    if(rotationField != ~UnsignedInt{}) {
        const SceneFieldType fieldType = _fields[rotationField]._fieldType;
        if(fieldType == SceneFieldType::Complex ||
           fieldType == SceneFieldType::Complexd) {
            CORRADE_ASSERT(!_dimensions || _dimensions == 2,
                "Trade::SceneData: expected a 3D rotation field but got" << fieldType, );
            _dimensions = 2;
        } else if(fieldType == SceneFieldType::Quaternion ||
                  fieldType == SceneFieldType::Quaterniond) {
            CORRADE_ASSERT(!_dimensions || _dimensions == 3,
                "Trade::SceneData: expected a 2D rotation field but got" << fieldType, );
            _dimensions = 3;
        } else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
    }
    if(scalingField != ~UnsignedInt{}) {
        const SceneFieldType fieldType = _fields[scalingField]._fieldType;
        if(fieldType == SceneFieldType::Vector2 ||
           fieldType == SceneFieldType::Vector2d) {
            CORRADE_ASSERT(!_dimensions || _dimensions == 2,
                "Trade::SceneData: expected a 3D scaling field but got" << fieldType, );
            _dimensions = 2;
        } else if(fieldType == SceneFieldType::Vector3 ||
                  fieldType == SceneFieldType::Vector3d) {
            CORRADE_ASSERT(!_dimensions || _dimensions == 3,
                "Trade::SceneData: expected a 2D scaling field but got" << fieldType, );
            _dimensions = 3;
        } else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
    }

    /* A skin field requires some transformation field to exist in order to
       disambiguate between 2D and 3D */
    CORRADE_ASSERT(skinField == ~UnsignedInt{} || _dimensions,
        "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 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} {
    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} {}

#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} {
    /* 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
       API which ... forces you to have a separate scene for 2D and 3D. But you
       can share the data among the two, at least. */
    CORRADE_ASSERT(children2D.empty() || children3D.empty(),
        "Trade::SceneData: it's no longer possible to have a scene with both 2D and 3D objects", );
    Containers::ArrayView<const UnsignedInt> children;
    if(!children2D.empty()) {
        _dimensions = 2;
        children = children2D;
    } else if(!children3D.empty()) {
        _dimensions = 3;
        children = children3D;
    } else _dimensions = 0;

    /* Set object count 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;

    /* 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<Int> parents;
    _data = Containers::ArrayTuple{
        {NoInit, children.size(), objects},
        {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);
    constexpr Int parent[]{-1};
    Utility::copy(Containers::stridedArrayView(parent).broadcasted<0>(parents.size()), parents);
}
#endif

SceneData::SceneData(SceneData&&) noexcept = default;

SceneData::~SceneData() = default;

SceneData& SceneData::operator=(SceneData&&) noexcept = default;

Containers::ArrayView<char> SceneData::mutableData() & {
    CORRADE_ASSERT(_dataFlags & DataFlag::Mutable,
        "Trade::SceneData::mutableData(): data not mutable", {});
    return _data;
}

Containers::StridedArrayView1D<const void> SceneData::fieldDataObjectViewInternal(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};
}

Containers::StridedArrayView1D<const void> SceneData::fieldDataObjectViewInternal(const SceneFieldData& field) const {
    return fieldDataObjectViewInternal(field, 0, field._size);
}

Containers::StridedArrayView1D<const void> SceneData::fieldDataFieldViewInternal(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._fieldData.offset : field._fieldData.pointer)
            + field._fieldStride*offset, ~std::size_t{}},
        size, field._fieldStride};
}

Containers::StridedArrayView1D<const void> SceneData::fieldDataFieldViewInternal(const SceneFieldData& field) const {
    return fieldDataFieldViewInternal(field, 0, field._size);
}

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

SceneField SceneData::fieldName(const UnsignedInt id) const {
    CORRADE_ASSERT(id < _fields.size(),
        "Trade::SceneData::fieldName(): index" << id << "out of range for" << _fields.size() << "fields", {});
    return _fields[id]._name;
}

SceneFieldType SceneData::fieldType(const UnsignedInt id) const {
    CORRADE_ASSERT(id < _fields.size(),
        "Trade::SceneData::fieldType(): index" << id << "out of range for" << _fields.size() << "fields", {});
    return _fields[id]._fieldType;
}

std::size_t SceneData::fieldSize(const UnsignedInt id) const {
    CORRADE_ASSERT(id < _fields.size(),
        "Trade::SceneData::fieldSize(): index" << id << "out of range for" << _fields.size() << "fields", {});
    return _fields[id]._size;
}

UnsignedShort SceneData::fieldArraySize(const UnsignedInt id) const {
    CORRADE_ASSERT(id < _fields.size(),
        "Trade::SceneData::fieldArraySize(): index" << id << "out of range for" << _fields.size() << "fields", {});
    return _fields[id]._fieldArraySize;
}

UnsignedInt SceneData::findFieldIdInternal(const SceneField name) const {
    for(std::size_t i = 0; i != _fields.size(); ++i)
        if(_fields[i]._name == name) return i;
    return ~UnsignedInt{};
}

Containers::Optional<UnsignedInt> SceneData::findFieldId(const SceneField name) const {
    const UnsignedInt fieldId = findFieldIdInternal(name);
    return fieldId == ~UnsignedInt{} ? Containers::Optional<UnsignedInt>{} : fieldId;
}

UnsignedInt SceneData::fieldId(const SceneField name) const {
    const UnsignedInt fieldId = findFieldIdInternal(name);
    CORRADE_ASSERT(fieldId != ~UnsignedInt{}, "Trade::SceneData::fieldId(): field" << name << "not found", {});
    return fieldId;
}

bool SceneData::hasField(const SceneField name) const {
    return findFieldIdInternal(name) != ~UnsignedInt{};
}

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();
    /** @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;
    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);
    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(fieldId < _fields.size(),
        "Trade::SceneData::findFieldObjectOffset(): index" << fieldId << "out of range for" << _fields.size() << "fields", {});

    const SceneFieldData& field = _fields[fieldId];
    CORRADE_ASSERT(offset <= field._size,
        "Trade::SceneData::findFieldObjectOffset(): offset" << offset << "out of bounds for a field of size" << field._size, {});

    const std::size_t found = findFieldObjectOffsetInternal(field, object, offset);
    return found == field._size ? Containers::Optional<std::size_t>{} : found;
}

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", {});

    const UnsignedInt fieldId = findFieldIdInternal(fieldName);
    CORRADE_ASSERT(fieldId != ~UnsignedInt{},
        "Trade::SceneData::findFieldObjectOffset(): field" << fieldName << "not found", {});

    const SceneFieldData& field = _fields[fieldId];
    CORRADE_ASSERT(offset <= field._size,
        "Trade::SceneData::findFieldObjectOffset(): offset" << offset << "out of bounds for a field of size" << field._size, {});

    const std::size_t found = findFieldObjectOffsetInternal(field, object, offset);
    return found == field._size ? Containers::Optional<std::size_t>{} : found;
}

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(fieldId < _fields.size(),
        "Trade::SceneData::fieldObjectOffset(): index" << fieldId << "out of range for" << _fields.size() << "fields", {});

    const SceneFieldData& field = _fields[fieldId];
    CORRADE_ASSERT(offset <= field._size,
        "Trade::SceneData::fieldObjectOffset(): offset" << offset << "out of bounds for a field of size" << field._size, {});

    const std::size_t found = findFieldObjectOffsetInternal(field, object, offset);
    CORRADE_ASSERT(found != field._size,
        "Trade::SceneData::fieldObjectOffset(): object" << object << "not found in field" << field._name << "starting at offset" << offset, {});
    return found;
}

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", {});

    const UnsignedInt fieldId = findFieldIdInternal(fieldName);
    CORRADE_ASSERT(fieldId != ~UnsignedInt{},
        "Trade::SceneData::fieldObjectOffset(): field" << fieldName << "not found", {});

    const SceneFieldData& field = _fields[fieldId];
    CORRADE_ASSERT(offset <= field._size,
        "Trade::SceneData::fieldObjectOffset(): offset" << offset << "out of bounds for a field of size" << field._size, {});

    const std::size_t found = findFieldObjectOffsetInternal(field, object, offset);
    CORRADE_ASSERT(found != field._size,
        "Trade::SceneData::fieldObjectOffset(): object" << object << "not found in field" << field._name << "starting at offset" << offset, {});
    return found;
}

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(fieldId < _fields.size(),
        "Trade::SceneData::hasFieldObject(): index" << fieldId << "out of range for" << _fields.size() << "fields", {});

    const SceneFieldData& field = _fields[fieldId];
    return findFieldObjectOffsetInternal(field, object, 0) != field._size;
}

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", {});

    const UnsignedInt fieldId = findFieldIdInternal(fieldName);
    CORRADE_ASSERT(fieldId != ~UnsignedInt{},
        "Trade::SceneData::hasFieldObject(): field" << fieldName << "not found", {});

    const SceneFieldData& field = _fields[fieldId];
    return findFieldObjectOffsetInternal(field, object, 0) != field._size;
}

SceneFieldType SceneData::fieldType(const SceneField name) const {
    const UnsignedInt fieldId = findFieldIdInternal(name);
    CORRADE_ASSERT(fieldId != ~UnsignedInt{}, "Trade::SceneData::fieldType(): field" << name << "not found", {});
    return _fields[fieldId]._fieldType;
}

std::size_t SceneData::fieldSize(const SceneField name) const {
    const UnsignedInt fieldId = findFieldIdInternal(name);
    CORRADE_ASSERT(fieldId != ~UnsignedInt{}, "Trade::SceneData::fieldSize(): field" << name << "not found", {});
    return _fields[fieldId]._size;
}

UnsignedShort SceneData::fieldArraySize(const SceneField name) const {
    const UnsignedInt fieldId = findFieldIdInternal(name);
    CORRADE_ASSERT(fieldId != ~UnsignedInt{}, "Trade::SceneData::fieldArraySize(): field" << name << "not found", {});
    return _fields[fieldId]._fieldArraySize;
}

Containers::StridedArrayView2D<const char> SceneData::objects(const UnsignedInt fieldId) const {
    CORRADE_ASSERT(fieldId < _fields.size(),
        "Trade::SceneData::objects(): index" << fieldId << "out of range for" << _fields.size() << "fields", {});
    const SceneFieldData& field = _fields[fieldId];
    /* Build a 2D view using information about object type size */
    return Containers::arrayCast<2, const char>(
        fieldDataObjectViewInternal(field),
        sceneObjectTypeSize(field._objectType));
}

Containers::StridedArrayView2D<char> SceneData::mutableObjects(const UnsignedInt fieldId) {
    CORRADE_ASSERT(_dataFlags & DataFlag::Mutable,
        "Trade::SceneData::mutableObjects(): data not mutable", {});
    CORRADE_ASSERT(fieldId < _fields.size(),
        "Trade::SceneData::mutableObjects(): 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));
    /** @todo some arrayConstCast? UGH */
    return Containers::StridedArrayView2D<char>{
        /* The view size is there only for a size assert, we're pretty sure the
           view is valid */
        {static_cast<char*>(const_cast<void*>(out.data())), ~std::size_t{}},
        out.size(), out.stride()};
}

Containers::StridedArrayView2D<const char> SceneData::objects(const SceneField fieldName) const {
    const UnsignedInt fieldId = findFieldIdInternal(fieldName);
    CORRADE_ASSERT(fieldId != ~UnsignedInt{}, "Trade::SceneData::objects(): field" << fieldName << "not found", {});
    return objects(fieldId);
}

Containers::StridedArrayView2D<char> SceneData::mutableObjects(const SceneField fieldName) {
    CORRADE_ASSERT(_dataFlags & DataFlag::Mutable,
        "Trade::SceneData::mutableObjects(): data not mutable", {});
    const UnsignedInt fieldId = findFieldIdInternal(fieldName);
    CORRADE_ASSERT(fieldId != ~UnsignedInt{}, "Trade::SceneData::mutableObjects(): field" << fieldName << "not found", {});
    return mutableObjects(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 */
    return Containers::arrayCast<2, const char>(
        fieldDataFieldViewInternal(field),
        sceneFieldTypeSize(field._fieldType)*(field._fieldArraySize ? field._fieldArraySize : 1));
}

Containers::StridedArrayView2D<char> SceneData::mutableField(const UnsignedInt id) {
    CORRADE_ASSERT(_dataFlags & DataFlag::Mutable,
        "Trade::SceneData::mutableField(): data not mutable", {});
    CORRADE_ASSERT(id < _fields.size(),
        "Trade::SceneData::mutableField(): index" << id << "out of range for" << _fields.size() << "fields", {});
    const SceneFieldData& field = _fields[id];
    /* Build a 2D view using information about attribute type size */
    const auto out = Containers::arrayCast<2, const char>(
        fieldDataFieldViewInternal(field),
        sceneFieldTypeSize(field._fieldType)*(field._fieldArraySize ? field._fieldArraySize : 1));
    /** @todo some arrayConstCast? UGH */
    return Containers::StridedArrayView2D<char>{
        /* The view size is there only for a size assert, we're pretty sure the
           view is valid */
        {static_cast<char*>(const_cast<void*>(out.data())), ~std::size_t{}},
        out.size(), out.stride()};
}

Containers::StridedArrayView2D<const char> SceneData::field(const SceneField name) const {
    const UnsignedInt fieldId = findFieldIdInternal(name);
    CORRADE_ASSERT(fieldId != ~UnsignedInt{},
        "Trade::SceneData::field(): field" << name << "not found", {});
    return field(fieldId);
}

Containers::StridedArrayView2D<char> SceneData::mutableField(const SceneField name) {
    CORRADE_ASSERT(_dataFlags & DataFlag::Mutable,
        "Trade::SceneData::mutableField(): data not mutable", {});
    const UnsignedInt fieldId = findFieldIdInternal(name);
    CORRADE_ASSERT(fieldId != ~UnsignedInt{},
        "Trade::SceneData::mutableField(): field" << name << "not found", {});
    return mutableField(fieldId);
}

void SceneData::objectsIntoInternal(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 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);
    } else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
}

void SceneData::objectsInto(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", );
    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);
}

std::size_t SceneData::objectsInto(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", {});
    CORRADE_ASSERT(offset <= _fields[fieldId]._size,
        "Trade::SceneData::objectsInto(): 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));
    return size;
}

Containers::Array<UnsignedInt> SceneData::objectsAsArray(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", {});
    Containers::Array<UnsignedInt> out{NoInit, std::size_t(_fields[fieldId]._size)};
    objectsIntoInternal(fieldId, 0, out);
    return out;
}

void SceneData::objectsInto(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);
}

std::size_t SceneData::objectsInto(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);
}

Containers::Array<UnsignedInt> SceneData::objectsAsArray(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);
}

void SceneData::parentsIntoInternal(const UnsignedInt fieldId, const std::size_t offset, const Containers::StridedArrayView1D<Int>& 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> fieldData = fieldDataFieldViewInternal(field, offset, destination.size());
    const auto destination1i = Containers::arrayCast<2, Int>(destination);

    if(field._fieldType == SceneFieldType::Int)
        Utility::copy(Containers::arrayCast<const Int>(fieldData), destination);
    else if(field._fieldType == SceneFieldType::Short)
        Math::castInto(Containers::arrayCast<2, const Short>(fieldData, 1), destination1i);
    else if(field._fieldType == SceneFieldType::Byte)
        Math::castInto(Containers::arrayCast<2, const Byte>(fieldData, 1), destination1i);
    else if(field._fieldType == SceneFieldType::Long) {
        Math::castInto(Containers::arrayCast<2, const Long>(fieldData, 1), destination1i);
    } else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
}

void SceneData::parentsInto(const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, 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(!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);
    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 {
    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));
    if(fieldDestination) parentsIntoInternal(fieldId, offset, fieldDestination.prefix(size));
    return size;
}

Containers::Array<Containers::Pair<UnsignedInt, Int>> SceneData::parentsAsArray() const {
    const UnsignedInt fieldId = findFieldIdInternal(SceneField::Parent);
    CORRADE_ASSERT(fieldId != ~UnsignedInt{},
        /* Using the same message as in Into() to avoid too many redundant
           strings in the binary */
        "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)});
    parentsIntoInternal(fieldId, 0, {out, reinterpret_cast<Int*>(reinterpret_cast<char*>(out.data()) + sizeof(UnsignedInt)), out.size(), sizeof(decltype(out)::Type)});
    return out;
}

namespace {

template<class Source, class Destination> void convertTransformation(const Containers::StridedArrayView1D<const void>& source, const Containers::StridedArrayView1D<Destination>& destination) {
    CORRADE_INTERNAL_ASSERT(source.size() == destination.size());
    const auto sourceT = Containers::arrayCast<const Source>(source);
    for(std::size_t i = 0; i != sourceT.size(); ++i)
        destination[i] = Destination{sourceT[i].toMatrix()};
}

/* Expands 2x3 to 3x3, 4x3 to 4x4, while potentially also converting floats to
   doubles */
/** @todo also have some optimized batched API for this? doing a strided copy
    and a fill seemed silly as that would cause the whole memory go through
    cache twice */
template<class Source, class Destination> void expandTransformationMatrix(const Containers::StridedArrayView1D<const void>& source, const Containers::StridedArrayView1D<Destination>& destination) {
    CORRADE_INTERNAL_ASSERT(source.size() == destination.size());
    const auto sourceT = Containers::arrayCast<const Source>(source);
    for(std::size_t i = 0; i != sourceT.size(); ++i)
        destination[i] = Destination{Math::RectangularMatrix<Source::Cols, Source::Rows, Float>{sourceT[i]}};
}

/** @todo these (or the float variants at least) should eventually be replaced
    with optimized batched APIs (applyTranslationsInto() updating just the
    last matrix column etc.) */

template<class Source, class Destination> void applyTranslation(const Containers::StridedArrayView1D<const void>& source, const Containers::StridedArrayView1D<Destination>& destination) {
    CORRADE_INTERNAL_ASSERT(source.size() == destination.size());
    const auto sourceT = Containers::arrayCast<const Source>(source);
    for(std::size_t i = 0; i != sourceT.size(); ++i)
        destination[i] = Destination::translation(Math::Vector<Destination::Size - 1, Float>{sourceT[i]})*destination[i];
}

template<class Source, class Destination> void applyRotation(const Containers::StridedArrayView1D<const void>& source, const Containers::StridedArrayView1D<Destination>& destination) {
    CORRADE_INTERNAL_ASSERT(source.size() == destination.size());
    const auto sourceT = Containers::arrayCast<const Source>(source);
    for(std::size_t i = 0; i != sourceT.size(); ++i)
        destination[i] = Destination{Math::Matrix<Destination::Size - 1, Float>{ sourceT[i].toMatrix()}}*destination[i];
}

template<class Source, class Destination> void applyScaling(const Containers::StridedArrayView1D<const void>& source, const Containers::StridedArrayView1D<Destination>& destination) {
    CORRADE_INTERNAL_ASSERT(source.size() == destination.size());
    const auto sourceT = Containers::arrayCast<const Source>(source);
    for(std::size_t i = 0; i != sourceT.size(); ++i)
        destination[i] = Destination::scaling(Math::Vector<Destination::Size - 1, Float>{sourceT[i]})*destination[i];
}

}

UnsignedInt SceneData::findTransformFields(UnsignedInt& transformationFieldId, UnsignedInt& translationFieldId, UnsignedInt& rotationFieldId, UnsignedInt& scalingFieldId) const {
    UnsignedInt fieldWithObjectMapping = ~UnsignedInt{};
    transformationFieldId = ~UnsignedInt{};
    translationFieldId = ~UnsignedInt{};
    rotationFieldId = ~UnsignedInt{};
    scalingFieldId = ~UnsignedInt{};
    for(std::size_t i = 0; i != _fields.size(); ++i) {
        /* If we find a transformation field, we don't need to look any
           further */
        if(_fields[i]._name == SceneField::Transformation) {
            fieldWithObjectMapping = transformationFieldId = i;
            break;
        } else if(_fields[i]._name == SceneField::Translation) {
            fieldWithObjectMapping = translationFieldId = i;
        } else if(_fields[i]._name == SceneField::Rotation) {
            fieldWithObjectMapping = rotationFieldId = i;
        } else if(_fields[i]._name == SceneField::Scaling) {
            fieldWithObjectMapping = scalingFieldId = i;
        }
    }

    return fieldWithObjectMapping;
}

UnsignedInt SceneData::findTranslationRotationScalingFields(UnsignedInt& translationFieldId, UnsignedInt& rotationFieldId, UnsignedInt& scalingFieldId) const {
    UnsignedInt fieldWithObjectMapping = ~UnsignedInt{};
    translationFieldId = ~UnsignedInt{};
    rotationFieldId = ~UnsignedInt{};
    scalingFieldId = ~UnsignedInt{};
    for(std::size_t i = 0; i != _fields.size(); ++i) {
        if(_fields[i]._name == SceneField::Translation) {
            fieldWithObjectMapping = translationFieldId = i;
        } else if(_fields[i]._name == SceneField::Rotation) {
            fieldWithObjectMapping = rotationFieldId = i;
        } else if(_fields[i]._name == SceneField::Scaling) {
            fieldWithObjectMapping = scalingFieldId = i;
        }
    }

    return fieldWithObjectMapping;
}

void SceneData::transformations2DIntoInternal(const UnsignedInt transformationFieldId, const UnsignedInt translationFieldId, const UnsignedInt rotationFieldId, const UnsignedInt scalingFieldId, std::size_t offset, const Containers::StridedArrayView1D<Matrix3>& destination) const {
    /* *FieldId, offset and destination.size() is assumed to be in bounds (or
       an invalid field ID), checked by the callers */

    /* If is2D() returned false as well, all *FieldId would be invalid, which
       the caller is assumed to check. */
    CORRADE_ASSERT(!is3D(), "Trade::SceneData::transformations2DInto(): scene has a 3D transformation type", );

    /** @todo apply scalings as well if dual complex? */

    /* Prefer the transformation field, if present */
    if(transformationFieldId != ~UnsignedInt{}) {
        const SceneFieldData& field = _fields[transformationFieldId];
        const Containers::StridedArrayView1D<const void> fieldData = fieldDataFieldViewInternal(field, offset, destination.size());
        const auto destination1f = Containers::arrayCast<2, Float>(destination);

        if(field._fieldType == SceneFieldType::Matrix3x3) {
            Utility::copy(Containers::arrayCast<const Matrix3>(fieldData), destination);
        } else if(field._fieldType == SceneFieldType::Matrix3x3d) {
            Math::castInto(Containers::arrayCast<2, const Double>(fieldData, 9), destination1f);
        } else if(field._fieldType == SceneFieldType::Matrix3x2) {
            expandTransformationMatrix<Matrix3x2>(fieldData, destination);
        } else if(field._fieldType == SceneFieldType::Matrix3x2d) {
            expandTransformationMatrix<Matrix3x2d>(fieldData, destination);
        } else if(field._fieldType == SceneFieldType::DualComplex) {
            convertTransformation<DualComplex>(fieldData, destination);
        } else if(field._fieldType == SceneFieldType::DualComplexd) {
            convertTransformation<DualComplexd>(fieldData, destination);
        } else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */

    /* If not, combine from TRS components */
    } else if(translationFieldId != ~UnsignedInt{} || rotationFieldId != ~UnsignedInt{} || scalingFieldId != ~UnsignedInt{}) {
        /* First fill the destination with identity matrices */
        const Matrix3 identity[1]{Matrix3{Math::IdentityInit}};
        Utility::copy(Containers::stridedArrayView(identity).broadcasted<0>(destination.size()), destination);

        /* Apply scaling first, if present */
        if(scalingFieldId != ~UnsignedInt{}) {
            const SceneFieldData& field = _fields[scalingFieldId];
            const Containers::StridedArrayView1D<const void> fieldData = fieldDataFieldViewInternal(field, offset, destination.size());

            if(field._fieldType == SceneFieldType::Vector2) {
                applyScaling<Vector2>(fieldData, destination);
            } else if(field._fieldType == SceneFieldType::Vector2d) {
                applyScaling<Vector2d>(fieldData, destination);
            } else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
        }

        /* Apply rotation second, if present */
        if(rotationFieldId != ~UnsignedInt{}) {
            const SceneFieldData& field = _fields[rotationFieldId];
            const Containers::StridedArrayView1D<const void> fieldData = fieldDataFieldViewInternal(field, offset, destination.size());

            if(field._fieldType == SceneFieldType::Complex) {
                applyRotation<Complex>(fieldData, destination);
            } else if(field._fieldType == SceneFieldType::Complexd) {
                applyRotation<Complexd>(fieldData, destination);
            } else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
        }

        /* Apply translation last, if present */
        if(translationFieldId != ~UnsignedInt{}) {
            const SceneFieldData& field = _fields[translationFieldId];
            const Containers::StridedArrayView1D<const void> fieldData = fieldDataFieldViewInternal(field, offset, destination.size());

            if(field._fieldType == SceneFieldType::Vector2) {
                applyTranslation<Vector2>(fieldData, destination);
            } else if(field._fieldType == SceneFieldType::Vector2d) {
                applyTranslation<Vector2d>(fieldData, destination);
            } else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
        }

    /* Checked in the caller */
    } else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
}

void SceneData::transformations2DInto(const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, 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(!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);
    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 {
    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", {});
    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));
    if(fieldDestination) transformations2DIntoInternal(transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId, offset, fieldDestination.prefix(size));
    return size;
}

Containers::Array<Containers::Pair<UnsignedInt, Matrix3>> SceneData::transformations2DAsArray() const {
    UnsignedInt transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId;
    const UnsignedInt fieldWithObjectMapping = findTransformFields(transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId);
    CORRADE_ASSERT(fieldWithObjectMapping != ~UnsignedInt{},
        /* Using the same message as in Into() to avoid too many redundant
           strings in the binary */
        "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)});
    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;
}

void SceneData::translationsRotationsScalings2DIntoInternal(const UnsignedInt translationFieldId, const UnsignedInt rotationFieldId, const UnsignedInt scalingFieldId, const std::size_t offset, const Containers::StridedArrayView1D<Vector2>& translationDestination, const Containers::StridedArrayView1D<Complex>& rotationDestination, const Containers::StridedArrayView1D<Vector2>& scalingDestination) const {
    /* *FieldId, offset and *Destination.size() is assumed to be in bounds (or
       an invalid field ID), checked by the callers */

    /* If is2D() returned false as well, all *FieldId would be invalid, which
       the caller is assumed to check. */
    CORRADE_ASSERT(!is3D(), "Trade::SceneData::translationsRotationsScalings2DInto(): scene has a 3D transformation type", );

    /* Retrieve translation, if desired. If no field is present, output a zero
       vector for all objects. */
    if(translationDestination) {
        if(translationFieldId == ~UnsignedInt{}) {
            constexpr Vector2 identity[]{Vector2{0.0f}};
            Utility::copy(Containers::stridedArrayView(identity).broadcasted<0>(translationDestination.size()), translationDestination);
        } else {
            const SceneFieldData& field = _fields[translationFieldId];
            const Containers::StridedArrayView1D<const void> fieldData = fieldDataFieldViewInternal(field, offset, translationDestination.size());

            if(field._fieldType == SceneFieldType::Vector2) {
                Utility::copy(Containers::arrayCast<const Vector2>(fieldData), translationDestination);
            } else if(field._fieldType == SceneFieldType::Vector2d) {
                Math::castInto(Containers::arrayCast<2, const Double>(fieldData, 2), Containers::arrayCast<2, Float>(translationDestination));
            } else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
        }
    }

    /* Retrieve rotation, if desired. If no field is present, output an
       identity rotation for all objects. */
    if(rotationDestination) {
        if(rotationFieldId == ~UnsignedInt{}) {
            constexpr Complex identity[]{Complex{Math::IdentityInit}};
            Utility::copy(Containers::stridedArrayView(identity).broadcasted<0>(rotationDestination.size()), rotationDestination);
        } else {
            const SceneFieldData& field = _fields[rotationFieldId];
            const Containers::StridedArrayView1D<const void> fieldData = fieldDataFieldViewInternal(field, offset, rotationDestination.size());

            if(field._fieldType == SceneFieldType::Complex) {
                Utility::copy(Containers::arrayCast<const Complex>(fieldData), rotationDestination);
            } else if(field._fieldType == SceneFieldType::Complexd) {
                Math::castInto(Containers::arrayCast<2, const Double>(fieldData, 2), Containers::arrayCast<2, Float>(rotationDestination));
            } else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
        }
    }

    /* Retrieve scaling, if desired. If no field is present, output an identity
       scaling for all objects. */
    if(scalingDestination) {
        if(scalingFieldId == ~UnsignedInt{}) {
            constexpr Vector2 identity[]{Vector2{1.0f}};
            Utility::copy(Containers::stridedArrayView(identity).broadcasted<0>(scalingDestination.size()), scalingDestination);
        } else {
            const SceneFieldData& field = _fields[scalingFieldId];
            const Containers::StridedArrayView1D<const void> fieldData = fieldDataFieldViewInternal(field, offset, scalingDestination.size());

            if(field._fieldType == SceneFieldType::Vector2) {
                Utility::copy(Containers::arrayCast<const Vector2>(fieldData), scalingDestination);
            } else if(field._fieldType == SceneFieldType::Vector2d) {
                Math::castInto(Containers::arrayCast<2, const Double>(fieldData, 2), Containers::arrayCast<2, Float>(scalingDestination));
            } else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
        }
    }
}

void SceneData::translationsRotationsScalings2DInto(const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, 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(!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);
    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 {
    UnsignedInt translationFieldId, rotationFieldId, scalingFieldId;
    const UnsignedInt fieldWithObjectMapping = findTranslationRotationScalingFields(translationFieldId, rotationFieldId, scalingFieldId);
    CORRADE_ASSERT(fieldWithObjectMapping != ~UnsignedInt{},
        "Trade::SceneData::translationsRotationsScalings2DInto(): no transformation-related field found", {});
    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(!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));
    translationsRotationsScalings2DIntoInternal(translationFieldId, rotationFieldId, scalingFieldId, offset,
        translationDestination ? translationDestination.prefix(size) : nullptr,
        rotationDestination ? rotationDestination.prefix(size) : nullptr,
        scalingDestination ? scalingDestination.prefix(size) : nullptr);
    return size;
}

Containers::Array<Containers::Pair<UnsignedInt, Containers::Triple<Vector2, Complex, Vector2>>> SceneData::translationsRotationsScalings2DAsArray() const {
    UnsignedInt translationFieldId, rotationFieldId, scalingFieldId;
    const UnsignedInt fieldWithObjectMapping = findTranslationRotationScalingFields(translationFieldId, rotationFieldId, scalingFieldId);
    CORRADE_ASSERT(fieldWithObjectMapping != ~UnsignedInt{},
        /* Using the same message as in Into() to avoid too many redundant
           strings in the binary */
        "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)});
    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)};
    translationsRotationsScalings2DIntoInternal(translationFieldId, rotationFieldId, scalingFieldId, 0, translationsOut, rotationsOut, scalingsOut);
    return out;
}

void SceneData::transformations3DIntoInternal(const UnsignedInt transformationFieldId, const UnsignedInt translationFieldId, const UnsignedInt rotationFieldId, const UnsignedInt scalingFieldId, const std::size_t offset, const Containers::StridedArrayView1D<Matrix4>& destination) const {
    /* *FieldId, offset and destination.size() is assumed to be in bounds (or
       an invalid field ID), checked by the callers */

    /* If is3D() returned false as well, all *FieldId would be invalid, which
       the caller is assumed to check. */
    CORRADE_ASSERT(!is2D(), "Trade::SceneData::transformations3DInto(): scene has a 2D transformation type", );

    /** @todo apply scalings as well if dual quat? */

    /* Prefer the transformation field, if present */
    if(transformationFieldId != ~UnsignedInt{}) {
        const SceneFieldData& field = _fields[transformationFieldId];
        const Containers::StridedArrayView1D<const void> fieldData = fieldDataFieldViewInternal(field, offset, destination.size());
        const auto destination1f = Containers::arrayCast<2, Float>(destination);

        if(field._fieldType == SceneFieldType::Matrix4x4) {
            Utility::copy(Containers::arrayCast<const Matrix4>(fieldData), destination);
        } else if(field._fieldType == SceneFieldType::Matrix4x4d) {
            Math::castInto(Containers::arrayCast<2, const Double>(fieldData, 16), destination1f);
        } else if(field._fieldType == SceneFieldType::Matrix4x3) {
            expandTransformationMatrix<Matrix4x3>(fieldData, destination);
        } else if(field._fieldType == SceneFieldType::Matrix4x3d) {
            expandTransformationMatrix<Matrix4x3d>(fieldData, destination);
        } else if(field._fieldType == SceneFieldType::DualQuaternion) {
            convertTransformation<DualQuaternion>(fieldData, destination);
        } else if(field._fieldType == SceneFieldType::DualQuaterniond) {
            convertTransformation<DualQuaterniond>(fieldData, destination);
        } else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */

    /* If not, combine from TRS components */
    } else if(translationFieldId != ~UnsignedInt{} || rotationFieldId != ~UnsignedInt{} || scalingFieldId != ~UnsignedInt{}) {
        /* First fill the destination with identity matrices */
        const Matrix4 identity[1]{Matrix4{Math::IdentityInit}};
        Utility::copy(Containers::stridedArrayView(identity).broadcasted<0>(destination.size()), destination);

        /* Apply scaling first, if present */
        if(scalingFieldId != ~UnsignedInt{}) {
            const SceneFieldData& field = _fields[scalingFieldId];
            const Containers::StridedArrayView1D<const void> fieldData = fieldDataFieldViewInternal(field, offset, destination.size());

            if(field._fieldType == SceneFieldType::Vector3) {
                applyScaling<Vector3>(fieldData, destination);
            } else if(field._fieldType == SceneFieldType::Vector3d) {
                applyScaling<Vector3d>(fieldData, destination);
            } else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
        }

        /* Apply rotation second, if present */
        if(rotationFieldId != ~UnsignedInt{}) {
            const SceneFieldData& field = _fields[rotationFieldId];
            const Containers::StridedArrayView1D<const void> fieldData = fieldDataFieldViewInternal(field, offset, destination.size());

            if(field._fieldType == SceneFieldType::Quaternion) {
                applyRotation<Quaternion>(fieldData, destination);
            } else if(field._fieldType == SceneFieldType::Quaterniond) {
                applyRotation<Quaterniond>(fieldData, destination);
            } else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
        }

        /* Apply translation last, if present */
        if(translationFieldId != ~UnsignedInt{}) {
            const SceneFieldData& field = _fields[translationFieldId];
            const Containers::StridedArrayView1D<const void> fieldData = fieldDataFieldViewInternal(field, offset, destination.size());

            if(field._fieldType == SceneFieldType::Vector3) {
                applyTranslation<Vector3>(fieldData, destination);
            } else if(field._fieldType == SceneFieldType::Vector3d) {
                applyTranslation<Vector3d>(fieldData, destination);
            } else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
        }

    /* Checked in the caller */
    } else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
}

void SceneData::transformations3DInto(const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, 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(!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);
    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 {
    UnsignedInt transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId;
    const UnsignedInt fieldWithObjectMapping = findTransformFields(transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId);
    CORRADE_ASSERT(fieldWithObjectMapping != ~UnsignedInt{},
        "Trade::SceneData::transformations3DInto(): no transformation-related field found", {});
    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));
    if(fieldDestination) transformations3DIntoInternal(transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId, offset, fieldDestination.prefix(size));
    return size;
}

Containers::Array<Containers::Pair<UnsignedInt, Matrix4>> SceneData::transformations3DAsArray() const {
    UnsignedInt transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId;
    const UnsignedInt fieldWithObjectMapping = findTransformFields(transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId);
    CORRADE_ASSERT(fieldWithObjectMapping != ~UnsignedInt{},
        /* Using the same message as in Into() to avoid too many redundant
           strings in the binary */
        "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)});
    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;
}

void SceneData::translationsRotationsScalings3DIntoInternal(const UnsignedInt translationFieldId, const UnsignedInt rotationFieldId, const UnsignedInt scalingFieldId, const std::size_t offset, const Containers::StridedArrayView1D<Vector3>& translationDestination, const Containers::StridedArrayView1D<Quaternion>& rotationDestination, const Containers::StridedArrayView1D<Vector3>& scalingDestination) const {
    /* *FieldId, offset and *Destination.size() is assumed to be in bounds (or
       an invalid field ID), checked by the callers */

    /* If is3D() returned false as well, all *FieldId would be invalid, which
       the caller is assumed to check. */
    CORRADE_ASSERT(!is2D(), "Trade::SceneData::translationsRotationsScalings3DInto(): scene has a 2D transformation type", );

    /* Retrieve translation, if desired. If no field is present, output a zero
       vector for all objects. */
    if(translationDestination) {
        if(translationFieldId == ~UnsignedInt{}) {
            constexpr Vector3 identity[]{Vector3{0.0f}};
            Utility::copy(Containers::stridedArrayView(identity).broadcasted<0>(translationDestination.size()), translationDestination);
        } else {
            const SceneFieldData& field = _fields[translationFieldId];
            const Containers::StridedArrayView1D<const void> fieldData = fieldDataFieldViewInternal(field, offset, translationDestination.size());

            if(field._fieldType == SceneFieldType::Vector3) {
                Utility::copy(Containers::arrayCast<const Vector3>(fieldData), translationDestination);
            } else if(field._fieldType == SceneFieldType::Vector3d) {
                Math::castInto(Containers::arrayCast<2, const Double>(fieldData, 3), Containers::arrayCast<2, Float>(translationDestination));
            } else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
        }
    }

    /* Retrieve rotation, if desired. If no field is present, output an
       identity rotation for all objects. */
    if(rotationDestination) {
        if(rotationFieldId == ~UnsignedInt{}) {
            constexpr Quaternion identity[]{Quaternion{Math::IdentityInit}};
            Utility::copy(Containers::stridedArrayView(identity).broadcasted<0>(rotationDestination.size()), rotationDestination);
        } else {
            const SceneFieldData& field = _fields[rotationFieldId];
            const Containers::StridedArrayView1D<const void> fieldData = fieldDataFieldViewInternal(field, offset, rotationDestination.size());

            if(field._fieldType == SceneFieldType::Quaternion) {
                Utility::copy(Containers::arrayCast<const Quaternion>(fieldData), rotationDestination);
            } else if(field._fieldType == SceneFieldType::Quaterniond) {
                Math::castInto(Containers::arrayCast<2, const Double>(fieldData, 4), Containers::arrayCast<2, Float>(rotationDestination));
            } else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
        }
    }

    /* Retrieve scaling, if desired. If no field is present, output an identity
       scaling for all objects. */
    if(scalingDestination) {
        if(scalingFieldId == ~UnsignedInt{}) {
            constexpr Vector3 identity[]{Vector3{1.0f}};
            Utility::copy(Containers::stridedArrayView(identity).broadcasted<0>(scalingDestination.size()), scalingDestination);
        } else {
            const SceneFieldData& field = _fields[scalingFieldId];
            const Containers::StridedArrayView1D<const void> fieldData = fieldDataFieldViewInternal(field, offset, scalingDestination.size());

            if(field._fieldType == SceneFieldType::Vector3) {
                Utility::copy(Containers::arrayCast<const Vector3>(fieldData), scalingDestination);
            } else if(field._fieldType == SceneFieldType::Vector3d) {
                Math::castInto(Containers::arrayCast<2, const Double>(fieldData, 3), Containers::arrayCast<2, Float>(scalingDestination));
            } else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
        }
    }
}

void SceneData::translationsRotationsScalings3DInto(const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, 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(!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);
    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 {
    UnsignedInt translationFieldId, rotationFieldId, scalingFieldId;
    const UnsignedInt fieldWithObjectMapping = findTranslationRotationScalingFields(translationFieldId, rotationFieldId, scalingFieldId);
    CORRADE_ASSERT(fieldWithObjectMapping != ~UnsignedInt{},
        "Trade::SceneData::translationsRotationsScalings3DInto(): no transformation-related field found", {});
    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(!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));
    translationsRotationsScalings3DIntoInternal(translationFieldId, rotationFieldId, scalingFieldId, offset,
        translationDestination ? translationDestination.prefix(size) : nullptr,
        rotationDestination ? rotationDestination.prefix(size) : nullptr,
        scalingDestination ? scalingDestination.prefix(size) : nullptr);
    return size;
}

Containers::Array<Containers::Pair<UnsignedInt, Containers::Triple<Vector3, Quaternion, Vector3>>> SceneData::translationsRotationsScalings3DAsArray() const {
    UnsignedInt translationFieldId, rotationFieldId, scalingFieldId;
    const UnsignedInt fieldWithObjectMapping = findTranslationRotationScalingFields(translationFieldId, rotationFieldId, scalingFieldId);
    CORRADE_ASSERT(fieldWithObjectMapping != ~UnsignedInt{},
        /* Using the same message as in Into() to avoid too many redundant
           strings in the binary */
        "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)});
    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)};
    translationsRotationsScalings3DIntoInternal(translationFieldId, rotationFieldId, scalingFieldId, 0, translationsOut, rotationsOut, scalingsOut);
    return out;
}

void SceneData::unsignedIndexFieldIntoInternal(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> fieldData = fieldDataFieldViewInternal(field, offset, destination.size());
    const auto destination1ui = Containers::arrayCast<2, UnsignedInt>(destination);

    if(field._fieldType == SceneFieldType::UnsignedInt)
        Utility::copy(Containers::arrayCast<const UnsignedInt>(fieldData), destination);
    else if(field._fieldType == SceneFieldType::UnsignedShort)
        Math::castInto(Containers::arrayCast<2, const UnsignedShort>(fieldData, 1), destination1ui);
    else if(field._fieldType == SceneFieldType::UnsignedByte)
        Math::castInto(Containers::arrayCast<2, const UnsignedByte>(fieldData, 1), destination1ui);
    else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
}

void SceneData::indexFieldIntoInternal(const UnsignedInt fieldId, const std::size_t offset, const Containers::StridedArrayView1D<Int>& 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> fieldData = fieldDataFieldViewInternal(field, offset, destination.size());
    const auto destination1ui = Containers::arrayCast<2, Int>(destination);

    if(field._fieldType == SceneFieldType::Int)
        Utility::copy(Containers::arrayCast<const Int>(fieldData), destination);
    else if(field._fieldType == SceneFieldType::Short)
        Math::castInto(Containers::arrayCast<2, const Short>(fieldData, 1), destination1ui);
    else if(field._fieldType == SceneFieldType::Byte)
        Math::castInto(Containers::arrayCast<2, const Byte>(fieldData, 1), destination1ui);
    else CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
}

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)});
    unsignedIndexFieldIntoInternal(fieldId, 0, {out, reinterpret_cast<UnsignedInt*>(reinterpret_cast<char*>(out.data()) + sizeof(UnsignedInt)), out.size(), sizeof(decltype(out)::Type)});
    return out;
}

void SceneData::meshesMaterialsIntoInternal(const UnsignedInt fieldId, const std::size_t offset, const Containers::StridedArrayView1D<UnsignedInt>& meshDestination, const Containers::StridedArrayView1D<Int>& meshMaterialDestination) const {
    /* fieldId, offset, meshDestination.size() and
       meshMaterialDestination.size() is assumed to be in bounds, checked by
       the callers */

    if(meshDestination)
        unsignedIndexFieldIntoInternal(fieldId, offset, meshDestination);

    /* Copy also the material, if desired. If no such field is present, output
       -1 for all meshes. */
    if(meshMaterialDestination) {
        const UnsignedInt materialFieldId = findFieldIdInternal(SceneField::MeshMaterial);
        if(materialFieldId == ~UnsignedInt{}) {
            constexpr Int invalid[]{-1};
            Utility::copy(Containers::stridedArrayView(invalid).broadcasted<0>(meshMaterialDestination.size()), meshMaterialDestination);
        } else indexFieldIntoInternal(materialFieldId, offset, meshMaterialDestination);
    }
}

void SceneData::meshesMaterialsInto(const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, 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(!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);
    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 {
    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(!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));
    meshesMaterialsIntoInternal(fieldId, offset,
        meshDestination ? meshDestination.prefix(size) : nullptr,
        meshMaterialDestination ? meshMaterialDestination.prefix(size) : nullptr);
    return size;
}

Containers::Array<Containers::Pair<UnsignedInt, Containers::Pair<UnsignedInt, Int>>> SceneData::meshesMaterialsAsArray() const {
    const UnsignedInt fieldId = findFieldIdInternal(SceneField::Mesh);
    CORRADE_ASSERT(fieldId != ~UnsignedInt{},
        /* Using the same message as in Into() to avoid too many redundant
           strings in the binary */
        "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)});
    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 {
    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(!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);
    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 {
    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));
    if(fieldDestination) unsignedIndexFieldIntoInternal(fieldId, offset, fieldDestination.prefix(size));
    return size;
}

Containers::Array<Containers::Pair<UnsignedInt, UnsignedInt>> SceneData::lightsAsArray() const {
    const UnsignedInt fieldId = findFieldIdInternal(SceneField::Light);
    CORRADE_ASSERT(fieldId != ~UnsignedInt{},
        /* Using the same message as in Into() to avoid too many redundant
           strings in the binary */
        "Trade::SceneData::lightsInto(): field not found", {});
    return unsignedIndexFieldAsArrayInternal(fieldId);
}

void SceneData::camerasInto(const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, 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(!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);
    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 {
    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));
    if(fieldDestination) unsignedIndexFieldIntoInternal(fieldId, offset, fieldDestination.prefix(size));
    return size;
}

Containers::Array<Containers::Pair<UnsignedInt, UnsignedInt>> SceneData::camerasAsArray() const {
    const UnsignedInt fieldId = findFieldIdInternal(SceneField::Camera);
    CORRADE_ASSERT(fieldId != ~UnsignedInt{},
        /* Using the same message as in Into() to avoid too many redundant
           strings in the binary */
        "Trade::SceneData::camerasInto(): field not found", {});
    return unsignedIndexFieldAsArrayInternal(fieldId);
}

void SceneData::skinsInto(const Containers::StridedArrayView1D<UnsignedInt>& objectDestination, 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(!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);
    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 {
    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));
    if(fieldDestination) unsignedIndexFieldIntoInternal(fieldId, offset, fieldDestination.prefix(size));
    return size;
}

Containers::Array<Containers::Pair<UnsignedInt, UnsignedInt>> SceneData::skinsAsArray() const {
    const UnsignedInt fieldId = findFieldIdInternal(SceneField::Skin);
    CORRADE_ASSERT(fieldId != ~UnsignedInt{},
        /* Using the same message as in Into() to avoid too many redundant
           strings in the binary */
        "Trade::SceneData::skinsInto(): field not found", {});
    return unsignedIndexFieldAsArrayInternal(fieldId);
}

void SceneData::importerStateIntoInternal(const UnsignedInt fieldId, const std::size_t offset, const Containers::StridedArrayView1D<const void*>& destination) const {
    /* fieldId, offset and destination.size() is assumed to be in bounds,
       checked by the callers */

    const SceneFieldData& field = _fields[fieldId];
    CORRADE_INTERNAL_ASSERT(field._fieldType == SceneFieldType::Pointer ||
                            field._fieldType == SceneFieldType::MutablePointer);
    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 {
    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(!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);
    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 {
    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));
    if(fieldDestination) importerStateIntoInternal(fieldId, offset, fieldDestination.prefix(size));
    return size;
}

Containers::Array<Containers::Pair<UnsignedInt, const void*>> SceneData::importerStateAsArray() const {
    const UnsignedInt fieldId = findFieldIdInternal(SceneField::ImporterState);
    CORRADE_ASSERT(fieldId != ~UnsignedInt{},
        /* Using the same message as in Into() to avoid too many redundant
           strings in the binary */
        "Trade::SceneData::importerStateInto(): field not found", {});
    Containers::Array<Containers::Pair<UnsignedInt, const void*>> out{
        /* There's padding before the pointer on 64bit, zero-initialize to
           avoid keeping random bytes in there */
        #ifdef CORRADE_TARGET_32BIT
        NoInit
        #else
        ValueInit
        #endif
    , 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)});
    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", {});

    const UnsignedInt fieldId = findFieldIdInternal(SceneField::Parent);
    if(fieldId == ~UnsignedInt{}) return {};

    const SceneFieldData& field = _fields[fieldId];
    const std::size_t offset = findFieldObjectOffsetInternal(field, object, 0);
    if(offset == field._size) return {};

    Int index[1];
    parentsIntoInternal(fieldId, offset, index);
    if(*index == -1) return -1;

    UnsignedInt parent[1];
    objectsIntoInternal(fieldId, *index, parent);
    return Int(*parent);
}

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", {});

    const UnsignedInt parentFieldId = findFieldIdInternal(SceneField::Parent);
    if(parentFieldId == ~UnsignedInt{}) return {};

    const SceneFieldData& parentField = _fields[parentFieldId];

    /* Figure out the parent object index to look for or -1 if we want
       top-level objects */
    Int parentIndexToLookFor;
    if(object == -1) parentIndexToLookFor = -1;
    else {
        const std::size_t parentObjectIndex = findFieldObjectOffsetInternal(parentField, object, 0);
        if(parentObjectIndex == parentField._size) return {};
        parentIndexToLookFor = parentObjectIndex;
    }

    /* Collect IDs of all objects that reference this index */
    Containers::Array<UnsignedInt> out;
    for(std::size_t offset = 0; offset != parentField.size(); ++offset) {
        Int parentIndex[1];
        parentsIntoInternal(parentFieldId, offset, parentIndex);
        if(*parentIndex == parentIndexToLookFor) {
            UnsignedInt child[1];
            /** @todo bleh slow, use the children <-> parent field proxying
                when implemented */
            objectsIntoInternal(parentFieldId, offset, child);
            arrayAppend(out, *child);
        }
    }

    return out;
}

Containers::Optional<Matrix3> SceneData::transformation2DFor(const UnsignedInt object) const {
    CORRADE_ASSERT(object < _objectCount,
        "Trade::SceneData::transformation2DFor(): object" << object << "out of bounds for" << _objectCount << "objects", {});

    UnsignedInt transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId;
    const UnsignedInt fieldWithObjectMapping = findTransformFields(transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId);
    if(fieldWithObjectMapping == ~UnsignedInt{}) return {};

    /* If is2D() returned false as well, all *FieldId would be invalid, which
       is handled above. */
    CORRADE_ASSERT(!is3D(), "Trade::SceneData::transformation2DFor(): scene has a 3D transformation type", {});

    const SceneFieldData& field = _fields[fieldWithObjectMapping];
    const std::size_t offset = findFieldObjectOffsetInternal(field, object, 0);
    if(offset == field._size) return {};

    Matrix3 transformation[1];
    transformations2DIntoInternal(transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId, offset, transformation);
    return *transformation;
}

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", {});

    UnsignedInt translationFieldId, rotationFieldId, scalingFieldId;
    const UnsignedInt fieldWithObjectMapping = findTranslationRotationScalingFields(translationFieldId, rotationFieldId, scalingFieldId);
    if(fieldWithObjectMapping == ~UnsignedInt{}) return {};

    /* If is2D() returned false as well, all *FieldId would be invalid, which
       is handled above. */
    CORRADE_ASSERT(!is3D(), "Trade::SceneData::translationRotationScaling2DFor(): scene has a 3D transformation type", {});

    const SceneFieldData& field = _fields[fieldWithObjectMapping];
    const std::size_t offset = findFieldObjectOffsetInternal(field, object, 0);
    if(offset == field._size) return {};

    Vector2 translation[1];
    Complex rotation[1];
    Vector2 scaling[1];
    translationsRotationsScalings2DIntoInternal(translationFieldId, rotationFieldId, scalingFieldId, offset, translation, rotation, scaling);
    return {InPlaceInit, *translation, *rotation, *scaling};
}

Containers::Optional<Matrix4> SceneData::transformation3DFor(const UnsignedInt object) const {
    CORRADE_ASSERT(object < _objectCount,
        "Trade::SceneData::transformation3DFor(): object" << object << "out of bounds for" << _objectCount << "objects", {});

    UnsignedInt transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId;
    const UnsignedInt fieldWithObjectMapping = findTransformFields(transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId);
    if(fieldWithObjectMapping == ~UnsignedInt{}) return {};

    /* If is3D() returned false as well, all *FieldId would be invalid, which
       is handled above. */
    CORRADE_ASSERT(!is2D(), "Trade::SceneData::transformation3DFor(): scene has a 2D transformation type", {});

    const SceneFieldData& field = _fields[fieldWithObjectMapping];
    const std::size_t offset = findFieldObjectOffsetInternal(field, object, 0);
    if(offset == field._size) return {};

    Matrix4 transformation[1];
    transformations3DIntoInternal(transformationFieldId, translationFieldId, rotationFieldId, scalingFieldId, offset, transformation);
    return *transformation;
}

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", {});

    UnsignedInt translationFieldId, rotationFieldId, scalingFieldId;
    const UnsignedInt fieldWithObjectMapping = findTranslationRotationScalingFields(translationFieldId, rotationFieldId, scalingFieldId);
    if(fieldWithObjectMapping == ~UnsignedInt{}) return {};

    /* If is3D() returned false as well, all *FieldId would be invalid, which
       is handled above. */
    CORRADE_ASSERT(!is2D(), "Trade::SceneData::translationRotationScaling3DFor(): scene has a 2D transformation type", {});

    const SceneFieldData& field = _fields[fieldWithObjectMapping];
    const std::size_t offset = findFieldObjectOffsetInternal(field, object, 0);
    if(offset == field._size) return {};

    Vector3 translation[1];
    Quaternion rotation[1];
    Vector3 scaling[1];
    translationsRotationsScalings3DIntoInternal(translationFieldId, rotationFieldId, scalingFieldId, offset, translation, rotation, scaling);
    return {InPlaceInit, *translation, *rotation, *scaling};
}

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", {});

    const UnsignedInt meshFieldId = findFieldIdInternal(SceneField::Mesh);
    if(meshFieldId == ~UnsignedInt{}) return {};

    const SceneFieldData& field = _fields[meshFieldId];
    Containers::Array<Containers::Pair<UnsignedInt, Int>> out;
    std::size_t offset = 0;
    for(;;) {
        offset = findFieldObjectOffsetInternal(field, object, offset);
        if(offset == field._size) break;

        UnsignedInt mesh[1];
        Int material[1];
        meshesMaterialsIntoInternal(meshFieldId, offset, mesh, material);
        arrayAppend(out, InPlaceInit, *mesh, *material);
        ++offset;
    }

    return out;
}

Containers::Array<UnsignedInt> SceneData::lightsFor(const UnsignedInt object) const {
    CORRADE_ASSERT(object < _objectCount,
        "Trade::SceneData::lightsFor(): object" << object << "out of bounds for" << _objectCount << "objects", {});

    const UnsignedInt fieldId = findFieldIdInternal(SceneField::Light);
    if(fieldId == ~UnsignedInt{}) return {};

    const SceneFieldData& field = _fields[fieldId];
    Containers::Array<UnsignedInt> out;
    std::size_t offset = 0;
    for(;;) {
        offset = findFieldObjectOffsetInternal(field, object, offset);
        if(offset == field._size) break;

        UnsignedInt index[1];
        unsignedIndexFieldIntoInternal(fieldId, offset, index);
        arrayAppend(out, InPlaceInit, *index);
        ++offset;
    }

    return out;
}

Containers::Array<UnsignedInt> SceneData::camerasFor(const UnsignedInt object) const {
    CORRADE_ASSERT(object < _objectCount,
        "Trade::SceneData::camerasFor(): object" << object << "out of bounds for" << _objectCount << "objects", {});

    const UnsignedInt fieldId = findFieldIdInternal(SceneField::Camera);
    if(fieldId == ~UnsignedInt{}) return {};

    const SceneFieldData& field = _fields[fieldId];
    Containers::Array<UnsignedInt> out;
    std::size_t offset = 0;
    for(;;) {
        offset = findFieldObjectOffsetInternal(field, object, offset);
        if(offset == field._size) break;

        UnsignedInt index[1];
        unsignedIndexFieldIntoInternal(fieldId, offset, index);
        arrayAppend(out, InPlaceInit, *index);
        ++offset;
    }

    return out;
}

Containers::Array<UnsignedInt> SceneData::skinsFor(const UnsignedInt object) const {
    CORRADE_ASSERT(object < _objectCount,
        "Trade::SceneData::skinsFor(): object" << object << "out of bounds for" << _objectCount << "objects", {});

    const UnsignedInt fieldId = findFieldIdInternal(SceneField::Skin);
    if(fieldId == ~UnsignedInt{}) return {};

    const SceneFieldData& field = _fields[fieldId];
    Containers::Array<UnsignedInt> out;
    std::size_t offset = 0;
    for(;;) {
        offset = findFieldObjectOffsetInternal(field, object, offset);
        if(offset == field._size) break;

        UnsignedInt index[1];
        unsignedIndexFieldIntoInternal(fieldId, offset, index);
        arrayAppend(out, InPlaceInit, *index);
        ++offset;
    }

    return out;
}

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", {});

    const UnsignedInt fieldId = findFieldIdInternal(SceneField::ImporterState);
    if(fieldId == ~UnsignedInt{}) return {};

    const SceneFieldData& field = _fields[fieldId];
    const std::size_t offset = findFieldObjectOffsetInternal(field, object, 0);
    if(offset == field._size) return {};

    const void* importerState[1];
    importerStateIntoInternal(fieldId, offset, importerState);
    return *importerState;
}

#ifdef MAGNUM_BUILD_DEPRECATED
std::vector<UnsignedInt> SceneData::children2D() const {
    if(_dimensions != 2) return {};

    /* Even though (or exactly because?) this API is deprecated, it's better to
       warn than to spend several hours debugging what's wrong */
    if(!hasField(SceneField::Parent))
        Warning{} << "Trade::SceneData::children2D(): no parent field present, returned array will be empty";

    const Containers::Array<UnsignedInt> children = childrenFor(-1);
    return {children.begin(), children.end()};
}

std::vector<UnsignedInt> SceneData::children3D() const {
    if(_dimensions != 3) return {};

    /* Even though (or exactly because?) this API is deprecated, it's better to
       warn than to spend several hours debugging what's wrong */
    if(!hasField(SceneField::Parent))
        Warning{} << "Trade::SceneData::children3D(): no parent field present, returned array will be empty";

    const Containers::Array<UnsignedInt> children = childrenFor(-1);
    return {children.begin(), children.end()};
}
#endif

Containers::Array<SceneFieldData> SceneData::releaseFieldData() {
    Containers::Array<SceneFieldData> out = std::move(_fields);
    _fields = {};
    return out;
}

Containers::Array<char> SceneData::releaseData() {
    _fields = {};
    Containers::Array<char> out = std::move(_data);
    _data = {};
    return out;
}

}}