src/gltf/gltf2_importer.cpp

/*
 * Copyright (c) 2022 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "gltf/gltf2_importer.h"

#include <chrono>
#include <cstring>
#include <functional>

#include <3d/ecs/components/animation_component.h>
#include <3d/ecs/components/animation_input_component.h>
#include <3d/ecs/components/animation_output_component.h>
#include <3d/ecs/components/animation_track_component.h>
#include <3d/ecs/components/camera_component.h>
#include <3d/ecs/components/environment_component.h>
#include <3d/ecs/components/light_component.h>
#include <3d/ecs/components/local_matrix_component.h>
#include <3d/ecs/components/material_component.h>
#include <3d/ecs/components/morph_component.h>
#include <3d/ecs/components/name_component.h>
#include <3d/ecs/components/node_component.h>
#include <3d/ecs/components/render_configuration_component.h>
#include <3d/ecs/components/render_handle_component.h>
#include <3d/ecs/components/render_mesh_component.h>
#include <3d/ecs/components/rsdz_model_id_component.h>
#include <3d/ecs/components/skin_ibm_component.h>
#include <3d/ecs/components/skin_joints_component.h>
#include <3d/ecs/components/transform_component.h>
#include <3d/ecs/components/uri_component.h>
#include <3d/ecs/components/world_matrix_component.h>
#include <3d/ecs/systems/intf_node_system.h>
#include <3d/ecs/systems/intf_skinning_system.h>
#include <3d/implementation_uids.h>
#include <3d/intf_graphics_context.h>
#include <3d/render/default_material_constants.h>
#include <3d/util/intf_mesh_builder.h>
#include <base/containers/fixed_string.h>
#include <base/containers/string.h>
#include <base/containers/unique_ptr.h>
#include <base/containers/unordered_map.h>
#include <base/containers/vector.h>
#include <base/math/matrix_util.h>
#include <base/math/vector_util.h>
#include <core/ecs/intf_ecs.h>
#include <core/ecs/intf_entity_manager.h>
#include <core/image/intf_image_container.h>
#include <core/image/intf_image_loader_manager.h>
#include <core/implementation_uids.h>
#include <core/intf_engine.h>
#include <core/log.h>
#include <core/namespace.h>
#include <core/perf/cpu_perf_scope.h>
#include <core/perf/intf_performance_data_manager.h>
#include <core/plugin/intf_class_register.h>
#include <core/property/intf_property_handle.h>
#include <core/property/property_types.h>
#include <render/datastore/intf_render_data_store_default_staging.h>
#include <render/datastore/intf_render_data_store_manager.h>
#include <render/device/intf_gpu_resource_manager.h>
#include <render/device/intf_shader_manager.h>
#include <render/implementation_uids.h>
#include <render/intf_render_context.h>

#include "gltf/gltf2_util.h"
#include "util/log.h"
#include "util/mesh_builder.h"
#include "util/mesh_util.h"
#include "util/string_util.h"
#include "util/uri_lookup.h"

CORE3D_BEGIN_NAMESPACE()
using namespace BASE_NS;
using namespace CORE_NS;
using namespace RENDER_NS;

namespace {
// How many threads the GLTF2Importer will use to run tasks.
constexpr const uint32_t IMPORTER_THREADS = 2u;

// Helper class for running lambda as a ThreadPool task.
template<typename Fn>
class FunctionTask final : public IThreadPool::ITask {
public:
    explicit FunctionTask(Fn&& func) : func_(BASE_NS::move(func)) {};

    void operator()() override
    {
        func_();
    }

protected:
    void Destroy() override
    {
        delete this;
    }

private:
    Fn func_;
};

template<typename Fn>
inline IThreadPool::ITask::Ptr CreateFunctionTask(Fn&& func)
{
    return IThreadPool::ITask::Ptr { new FunctionTask<Fn>(BASE_NS::move(func)) };
}

template<class T>
size_t FindIndex(const vector<unique_ptr<T>>& container, T const* item)
{
    for (size_t i = 0; i < container.size(); ++i) {
        if (container[i].get() == item) {
            return i;
        }
    }
    return GLTF2::GLTF_INVALID_INDEX;
}

constexpr auto MAX_COMPONENTS = 4U;
constexpr Format BYTE_FORMATS[2U][MAX_COMPONENTS] = {
    { BASE_FORMAT_R8_SINT, BASE_FORMAT_R8G8_SINT, BASE_FORMAT_R8G8B8_SINT, BASE_FORMAT_R8G8B8A8_SINT },
    { BASE_FORMAT_R8_SNORM, BASE_FORMAT_R8G8_SNORM, BASE_FORMAT_R8G8B8_SNORM, BASE_FORMAT_R8G8B8A8_SNORM },
};
constexpr Format UNSIGNED_BYTE_FORMATS[2U][MAX_COMPONENTS] = {
    { BASE_FORMAT_R8_UINT, BASE_FORMAT_R8G8_UINT, BASE_FORMAT_R8G8B8_UINT, BASE_FORMAT_R8G8B8A8_UINT },
    { BASE_FORMAT_R8_UNORM, BASE_FORMAT_R8G8_UNORM, BASE_FORMAT_R8G8B8_UNORM, BASE_FORMAT_R8G8B8A8_UNORM },
};

constexpr Format SHORT_FORMATS[2U][MAX_COMPONENTS] = {
    { BASE_FORMAT_R16_SINT, BASE_FORMAT_R16G16_SINT, BASE_FORMAT_R16G16B16_SINT, BASE_FORMAT_R16G16B16A16_SINT },
    { BASE_FORMAT_R16_SNORM, BASE_FORMAT_R16G16_SNORM, BASE_FORMAT_R16G16B16_SNORM, BASE_FORMAT_R16G16B16A16_SNORM },
};
constexpr Format UNSIGNED_SHORT_FORMATS[2U][MAX_COMPONENTS] = {
    { BASE_FORMAT_R16_UINT, BASE_FORMAT_R16G16_UINT, BASE_FORMAT_R16G16B16_UINT, BASE_FORMAT_R16G16B16A16_UINT },
    { BASE_FORMAT_R16_UNORM, BASE_FORMAT_R16G16_UNORM, BASE_FORMAT_R16G16B16_UNORM, BASE_FORMAT_R16G16B16A16_UNORM },
};

constexpr Format INT_FORMATS[MAX_COMPONENTS] = { BASE_FORMAT_R32_SINT, BASE_FORMAT_R32G32_SINT,
    BASE_FORMAT_R32G32B32_SINT, BASE_FORMAT_R32G32B32A32_SINT };
constexpr Format UNSIGNED_INT_FORMATS[MAX_COMPONENTS] = { BASE_FORMAT_R32_UINT, BASE_FORMAT_R32G32_UINT,
    BASE_FORMAT_R32G32B32_UINT, BASE_FORMAT_R32G32B32A32_UINT };

constexpr Format FLOAT_FORMATS[MAX_COMPONENTS] = { BASE_FORMAT_R32_SFLOAT, BASE_FORMAT_R32G32_SFLOAT,
    BASE_FORMAT_R32G32B32_SFLOAT, BASE_FORMAT_R32G32B32A32_SFLOAT };

constexpr Format Convert(GLTF2::ComponentType componentType, size_t componentCount, bool normalized)
{
    if (componentCount <= MAX_COMPONENTS) {
        switch (componentType) {
            case GLTF2::ComponentType::INVALID:
                break;

            case GLTF2::ComponentType::BYTE:
                return BYTE_FORMATS[normalized ? 1U : 0U][componentCount - 1];

            case GLTF2::ComponentType::UNSIGNED_BYTE:
                return UNSIGNED_BYTE_FORMATS[normalized ? 1U : 0U][componentCount - 1];

            case GLTF2::ComponentType::SHORT:
                return SHORT_FORMATS[normalized ? 1U : 0U][componentCount - 1];

            case GLTF2::ComponentType::UNSIGNED_SHORT:
                return UNSIGNED_SHORT_FORMATS[normalized ? 1U : 0U][componentCount - 1];

            case GLTF2::ComponentType::INT:
                return INT_FORMATS[componentCount - 1];

            case GLTF2::ComponentType::UNSIGNED_INT:
                return UNSIGNED_INT_FORMATS[componentCount - 1];

            case GLTF2::ComponentType::FLOAT:
                return FLOAT_FORMATS[componentCount - 1];
        }
    }
    return BASE_FORMAT_UNDEFINED;
}

constexpr GraphicsState::InputAssembly ConvertGltf2InputAssembly(const GLTF2::RenderMode renderMode)
{
    GraphicsState::InputAssembly ia;
    switch (renderMode) {
        case GLTF2::RenderMode::POINTS:
            ia.primitiveTopology = PrimitiveTopology::CORE_PRIMITIVE_TOPOLOGY_POINT_LIST;
            break;
        case GLTF2::RenderMode::LINES:
            ia.primitiveTopology = PrimitiveTopology::CORE_PRIMITIVE_TOPOLOGY_LINE_LIST;
            break;
        case GLTF2::RenderMode::LINE_STRIP:
            ia.primitiveTopology = PrimitiveTopology::CORE_PRIMITIVE_TOPOLOGY_LINE_STRIP;
            break;
        case GLTF2::RenderMode::TRIANGLES:
            ia.primitiveTopology = PrimitiveTopology::CORE_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
            break;
        case GLTF2::RenderMode::TRIANGLE_STRIP:
            ia.primitiveTopology = PrimitiveTopology::CORE_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
            break;
        case GLTF2::RenderMode::TRIANGLE_FAN:
            ia.primitiveTopology = PrimitiveTopology::CORE_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN;
            break;
        default:
            // PrimitiveTopology::CORE_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY
            // would need to be handled with line_strip with some additions
            ia.primitiveTopology = PrimitiveTopology::CORE_PRIMITIVE_TOPOLOGY_MAX_ENUM;
            break;
    }
    return ia;
}

void ConvertNormalizedDataToFloat(GLTF2::GLTFLoadDataResult const& result, float* destination,
    size_t dstComponentCount = 0, float paddingValue = 0.0f, float scale = 0.f)
{
    uint8_t const* source = reinterpret_cast<const uint8_t*>(result.data.data());

    if (dstComponentCount == 0) {
        // By default, use the source component count.
        dstComponentCount = result.componentCount;
    }

    CORE_ASSERT_MSG(dstComponentCount >= result.componentCount,
        "Padding count cannot be negative. Make sure expected component count is equal or greater than source "
        "component count.");

    // Amount of padding.
    const size_t paddingCount = dstComponentCount - result.componentCount;

    for (size_t i = 0; i < result.elementCount; ++i) {
        for (size_t j = 0; j < result.componentCount; ++j) {
            switch (result.componentType) {
                case GLTF2::ComponentType::BYTE:
                    *destination = std::max((reinterpret_cast<const int8_t*>(source))[j] / 127.0f, -1.0f);
                    break;

                case GLTF2::ComponentType::UNSIGNED_BYTE:
                    *destination = source[j] / 255.0f;
                    break;

                case GLTF2::ComponentType::SHORT:
                    *destination = std::max(
                        (reinterpret_cast<const int16_t*>(source))[j] / ((scale != 0.f) ? scale : 32767.0f), -1.0f);
                    break;

                case GLTF2::ComponentType::UNSIGNED_SHORT:
                    *destination = (reinterpret_cast<const uint16_t*>(source))[j] / 65535.0f;
                    break;

                case GLTF2::ComponentType::FLOAT: {
                    *destination = (reinterpret_cast<const float*>(reinterpret_cast<uintptr_t>(source)))[j];
                    break;
                }

                default:
                case GLTF2::ComponentType::UNSIGNED_INT:
                case GLTF2::ComponentType::INT:
                    CORE_ASSERT(false);
                    *destination = 0.0f;
                    break;
            }

            destination++;
        }

        // Apply padding.
        for (size_t padding = 0; padding < paddingCount; ++padding) {
            *destination = paddingValue;
            destination++;
        }

        source += result.elementSize;
    }
}

void ConvertDataToFloat(GLTF2::GLTFLoadDataResult const& result, float* destination, size_t dstComponentCount = 0,
    float paddingValue = 0.0f, float scale = 0.f)
{
    uint8_t const* source = reinterpret_cast<const uint8_t*>(result.data.data());

    if (dstComponentCount == 0) {
        // By default, use the source component count.
        dstComponentCount = result.componentCount;
    }

    CORE_ASSERT_MSG(dstComponentCount >= result.componentCount,
        "Padding count cannot be negative. Make sure expected component count is equal or greater than source "
        "component count.");

    // Amount of padding.
    const size_t paddingCount = dstComponentCount - result.componentCount;

    for (size_t i = 0; i < result.elementCount; ++i) {
        for (size_t j = 0; j < result.componentCount; ++j) {
            switch (result.componentType) {
                case GLTF2::ComponentType::BYTE:
                    *destination = reinterpret_cast<const int8_t*>(source)[j];
                    break;

                case GLTF2::ComponentType::UNSIGNED_BYTE:
                    *destination = source[j];
                    break;

                case GLTF2::ComponentType::SHORT:
                    *destination = reinterpret_cast<const int16_t*>(source)[j];
                    break;

                case GLTF2::ComponentType::UNSIGNED_SHORT:
                    *destination = reinterpret_cast<const uint16_t*>(source)[j];
                    break;

                case GLTF2::ComponentType::FLOAT: {
                    *destination = (reinterpret_cast<const float*>(reinterpret_cast<uintptr_t>(source)))[j];
                    break;
                }

                default:
                case GLTF2::ComponentType::UNSIGNED_INT:
                case GLTF2::ComponentType::INT:
                    CORE_ASSERT(false);
                    *destination = 0.0f;
                    break;
            }

            destination++;
        }

        // Apply padding.
        for (size_t padding = 0; padding < paddingCount; ++padding) {
            *destination = paddingValue;
            destination++;
        }

        source += result.elementSize;
    }
}

void ConvertDataToBool(GLTF2::GLTFLoadDataResult const& result, bool* destination)
{
    uint8_t const* source = reinterpret_cast<const uint8_t*>(result.data.data());

    for (size_t i = 0; i < result.elementCount; ++i) {
        for (size_t j = 0; j < result.componentCount; ++j) {
            switch (result.componentType) {
                case GLTF2::ComponentType::BYTE:
                    *destination = reinterpret_cast<const int8_t*>(source)[j] != 0;
                    break;

                case GLTF2::ComponentType::UNSIGNED_BYTE:
                    *destination = source[j] != 0u;
                    break;

                case GLTF2::ComponentType::SHORT:
                    *destination = reinterpret_cast<const int16_t*>(source)[j] != 0;
                    break;

                case GLTF2::ComponentType::UNSIGNED_SHORT:
                    *destination = reinterpret_cast<const uint16_t*>(source)[j] != 0u;
                    break;

                case GLTF2::ComponentType::FLOAT: {
                    *destination = reinterpret_cast<const float*>(reinterpret_cast<uintptr_t>(source))[j] != 0.f;
                    break;
                }

                default:
                case GLTF2::ComponentType::UNSIGNED_INT:
                case GLTF2::ComponentType::INT:
                    CORE_ASSERT(false);
                    *destination = false;
                    break;
            }

            destination++;
        }

        source += result.elementSize;
    }
}

EntityReference GetImportedTextureHandle(const GLTFImportResult& importResult, uint32_t index)
{
    if (index != GLTF2::GLTF_INVALID_INDEX && index < importResult.data.textures.size()) {
        return importResult.data.textures[index];
    }

    return EntityReference();
}

string_view GetImageExtension(GLTF2::MimeType type)
{
    switch (type) {
        case GLTF2::MimeType::JPEG:
            return "jpg";
        case GLTF2::MimeType::PNG:
            return "png";
        case GLTF2::MimeType::KTX:
            return "ktx";
        case GLTF2::MimeType::DDS:
            return "dds";

        case GLTF2::MimeType::INVALID:
        default:
            return "";
    }
}

LightComponent::Type ConvertToCoreLightType(GLTF2::LightType lightType)
{
    switch (lightType) {
        case GLTF2::LightType::DIRECTIONAL:
            return LightComponent::Type::DIRECTIONAL;

        case GLTF2::LightType::POINT:
            return LightComponent::Type::POINT;

        case GLTF2::LightType::SPOT:
            return LightComponent::Type::SPOT;

        default:
        case GLTF2::LightType::INVALID:
        case GLTF2::LightType::AMBIENT:
            return LightComponent::Type::DIRECTIONAL;
    }
}

struct GatherMeshDataResult {
    GatherMeshDataResult() = default;
    ~GatherMeshDataResult() = default;
    GatherMeshDataResult(const GatherMeshDataResult& aOther) = delete;
    explicit GatherMeshDataResult(const string& error) : success(false), error(error) {}
    GatherMeshDataResult(GatherMeshDataResult&& other) noexcept
        : success(other.success), error(move(other.error)), meshBuilder(move(other.meshBuilder))
    {}

    GatherMeshDataResult& operator=(GatherMeshDataResult&& other) noexcept
    {
        success = other.success;
        error = move(other.error);
        meshBuilder = move(other.meshBuilder);
        return *this;
    }

    /** Indicates, whether the load operation is successful. */
    bool success { true };

    /** In case of import error, contains the description of the error. */
    string error;

    BASE_NS::refcnt_ptr<MeshBuilder> meshBuilder;
};

void ConvertLoadResultToFloat(GLTF2::GLTFLoadDataResult& data, float scale = 0.f)
{
    vector<uint8_t> converted;
    auto const componentCount = data.elementCount * data.componentCount;
    converted.resize(componentCount * sizeof(float));
    if (data.normalized) {
        ConvertNormalizedDataToFloat(data, reinterpret_cast<float*>(converted.data()), 0u, 0.f, scale);
    } else {
        ConvertDataToFloat(data, reinterpret_cast<float*>(converted.data()), 0u, 0.f, scale);
    }

    data.componentType = GLTF2::ComponentType::FLOAT;
    data.componentByteSize = sizeof(float);
    data.elementSize = data.componentByteSize * data.componentCount;
    data.data = move(converted);
}

template<typename T>
void Validate(GLTF2::GLTFLoadDataResult& indices, uint32_t vertexCount, bool& primitiveRestart)
{
    const auto elementCount = Math::min(indices.elementCount, indices.data.size_in_bytes() / sizeof(T));
    auto source = array_view(static_cast<const T*>(static_cast<const void*>(indices.data.data())), elementCount);
    primitiveRestart = false;
    if (std::any_of(source.begin(), source.end(), [vertexCount, &primitiveRestart](const auto& value) {
            // spec prohibits "maximum possible value for component type", but still some models use it for primitive
            // restart.
            if (value == std::numeric_limits<T>::max()) {
                primitiveRestart = true;
                return false;
            }
            return (value >= vertexCount);
        })) {
        indices.success = false;
        indices.error += "Indices out-of-range.\n";
    }
}

void ValidateIndices(GLTF2::GLTFLoadDataResult& indices, uint32_t vertexCount, bool& primitiveRestart)
{
    switch (indices.componentType) {
        case GLTF2::ComponentType::UNSIGNED_BYTE: {
            Validate<uint8_t>(indices, vertexCount, primitiveRestart);
            break;
        }
        case GLTF2::ComponentType::UNSIGNED_SHORT: {
            Validate<uint16_t>(indices, vertexCount, primitiveRestart);
            break;
        }
        case GLTF2::ComponentType::UNSIGNED_INT: {
            Validate<uint32_t>(indices, vertexCount, primitiveRestart);
            break;
        }

        default:
        case GLTF2::ComponentType::BYTE:
        case GLTF2::ComponentType::SHORT:
        case GLTF2::ComponentType::FLOAT:
        case GLTF2::ComponentType::INT:
            indices.success = false;
            indices.error += "Invalid componentType for indices.\n";
            CORE_ASSERT(false);
            break;
    }
}

bool LoadPrimitiveAttributeData(const GLTF2::MeshPrimitive& primitive, GLTF2::GLTFLoadDataResult& positions,
    GLTF2::GLTFLoadDataResult& normals, array_view<GLTF2::GLTFLoadDataResult> texcoords,
    GLTF2::GLTFLoadDataResult& tangents, GLTF2::GLTFLoadDataResult& joints, GLTF2::GLTFLoadDataResult& weights,
    GLTF2::GLTFLoadDataResult& colors, const uint32_t& flags)
{
    bool success = true;
    for (const auto& attribute : primitive.attributes) {
        if ((attribute.attribute.type != GLTF2::AttributeType::TEXCOORD && attribute.attribute.index > 0) ||
            (attribute.attribute.type == GLTF2::AttributeType::TEXCOORD &&
                attribute.attribute.index >= texcoords.size())) {
            continue;
        }

        GLTF2::GLTFLoadDataResult loadDataResult = GLTF2::LoadData(*attribute.accessor);
        success = success && loadDataResult.success;
        switch (attribute.attribute.type) {
            case GLTF2::AttributeType::POSITION:
                positions = move(loadDataResult);
                break;

            case GLTF2::AttributeType::NORMAL:
                normals = move(loadDataResult);
                break;

            case GLTF2::AttributeType::TEXCOORD:
                texcoords[attribute.attribute.index] = move(loadDataResult);
                break;

            case GLTF2::AttributeType::TANGENT:
                tangents = move(loadDataResult);
                break;

            case GLTF2::AttributeType::JOINTS:
                if (flags & CORE_GLTF_IMPORT_RESOURCE_SKIN) {
                    joints = move(loadDataResult);
                }
                break;

            case GLTF2::AttributeType::WEIGHTS:
                if (flags & CORE_GLTF_IMPORT_RESOURCE_SKIN) {
                    weights = move(loadDataResult);
                }
                break;

            case GLTF2::AttributeType::COLOR:
                colors = move(loadDataResult);
                break;

            case GLTF2::AttributeType::INVALID:
            default:
                break;
        }
    }
    return success;
}

void ProcessMorphTargetData(const IMeshBuilder::Submesh& importInfo, size_t targets,
    GLTF2::GLTFLoadDataResult& loadDataResult, GLTF2::GLTFLoadDataResult& finalDataResult)
{
#if !defined(GLTF2_EXTENSION_KHR_MESH_QUANTIZATION)
    // Spec says POSITION,NORMAL and TANGENT must be FLOAT & VEC3
    // NOTE: ASSERT for now, if the types don't match, they need to be converted. (or we should fail
    // since out-of-spec)
    CORE_ASSERT(loadDataResult.componentType == GLTF2::ComponentType::FLOAT);
    CORE_ASSERT(loadDataResult.componentCount == 3U);
    CORE_ASSERT(loadDataResult.elementCount == importInfo.vertexCount);
#endif
    if (finalDataResult.componentCount > 0U) {
        finalDataResult.data.append(loadDataResult.data.begin(), loadDataResult.data.end());
        for (size_t i = 0; i < finalDataResult.min.size(); i++) {
            finalDataResult.min[i] = std::min(finalDataResult.min[i], loadDataResult.min[i]);
        }
        for (size_t i = 0; i < finalDataResult.max.size(); i++) {
            finalDataResult.max[i] = std::max(finalDataResult.max[i], loadDataResult.max[i]);
        }
    } else {
        finalDataResult = move(loadDataResult);
        finalDataResult.data.reserve(finalDataResult.data.size() * targets);
    }
}

void GenerateMorphTargets(const GLTF2::MeshPrimitive& primitive, const IMeshBuilder::Submesh& importInfo,
    GLTF2::GLTFLoadDataResult& targetPositions, GLTF2::GLTFLoadDataResult& targetNormals,
    GLTF2::GLTFLoadDataResult& targetTangents)
{
    // All targets collected to single buffer.
    for (const auto& target : primitive.targets) {
        for (const auto& targetAttribute : target.target) {
            GLTF2::GLTFLoadDataResult loadDataResult = GLTF2::LoadData(*targetAttribute.accessor);
            if (loadDataResult.success) {
                switch (targetAttribute.attribute.type) {
                    case GLTF2::AttributeType::POSITION:
#if defined(GLTF2_EXTENSION_IGFX_COMPRESSED)
                        // This is for the IGFX_compressed extension. Morph target offsets were multiplied by 10000(!)
                        // and cast to int16.
                        if (target.iGfxCompressed && loadDataResult.componentType == GLTF2::ComponentType::SHORT) {
                            loadDataResult.normalized = true;
                            ConvertLoadResultToFloat(loadDataResult, 10000.f);
                        }
#endif
                        ProcessMorphTargetData(importInfo, primitive.targets.size(), loadDataResult, targetPositions);
                        break;

                    case GLTF2::AttributeType::NORMAL:
                        ProcessMorphTargetData(importInfo, primitive.targets.size(), loadDataResult, targetNormals);
                        break;

                    case GLTF2::AttributeType::TANGENT:
                        ProcessMorphTargetData(importInfo, primitive.targets.size(), loadDataResult, targetTangents);
                        break;

                    case GLTF2::AttributeType::TEXCOORD:
                    case GLTF2::AttributeType::JOINTS:
                    case GLTF2::AttributeType::WEIGHTS:
                    case GLTF2::AttributeType::COLOR:
                    case GLTF2::AttributeType::INVALID:
                    default:
                        // NOTE: Technically there could be custom attributes, but those are not supported at all
                        // currently!
                        break;
                }
            }
        }
    }
}

IndexType GetPrimitiveIndexType(const GLTF2::MeshPrimitive& primitive)
{
    switch (primitive.indices->componentType) {
        case GLTF2::ComponentType::UNSIGNED_BYTE:
            return CORE_INDEX_TYPE_UINT16;

        case GLTF2::ComponentType::UNSIGNED_SHORT:
            return CORE_INDEX_TYPE_UINT16;

        case GLTF2::ComponentType::UNSIGNED_INT:
            return CORE_INDEX_TYPE_UINT32;

        case GLTF2::ComponentType::INVALID:
        case GLTF2::ComponentType::BYTE:
        case GLTF2::ComponentType::SHORT:
        case GLTF2::ComponentType::INT:
        case GLTF2::ComponentType::FLOAT:
            break;
        default:
            break;
    }

    CORE_ASSERT_MSG(false, "Not supported index type.");

    return CORE_INDEX_TYPE_UINT32;
}

bool ContainsAttribute(const GLTF2::MeshPrimitive& primitive, GLTF2::AttributeType type)
{
    return std::any_of(primitive.attributes.begin(), primitive.attributes.end(),
        [type](const GLTF2::Attribute& attribute) { return attribute.attribute.type == type; });
}

IMeshBuilder::Submesh CreatePrimitiveImportInfo(const GLTFImportResult& importResult,
    const IMaterialComponentManager& materialManager, const GLTF2::MeshPrimitive& primitive)
{
    IMeshBuilder::Submesh info;
    bool hasNormalMap = false;

    // Get material, if one assigned.
    if (primitive.materialIndex != GLTF2::GLTF_INVALID_INDEX &&
        primitive.materialIndex < importResult.data.materials.size()) {
        info.material = importResult.data.materials[primitive.materialIndex];
        hasNormalMap = (primitive.material->normalTexture.textureInfo.index != GLTF2::GLTF_INVALID_INDEX ||
                        primitive.material->clearcoat.normalTexture.textureInfo.index != GLTF2::GLTF_INVALID_INDEX);
    }

    info.colors = ContainsAttribute(primitive, GLTF2::AttributeType::COLOR);
    info.joints = ContainsAttribute(primitive, GLTF2::AttributeType::JOINTS);
    info.tangents = ContainsAttribute(primitive, GLTF2::AttributeType::TANGENT);
    if (!info.tangents) {
        // If material has normal map assigned, then always make sure that we have normals.
        info.tangents = hasNormalMap;
    }

    if (!info.tangents) {
        // NOTE. Currenty morph render node always writes tangent data to output buffer.
        // Therefore we must have tangents defined for this primitive.
        info.tangents = primitive.targets.size() > 0;
    }
    if (const auto pos = std::find_if(primitive.attributes.begin(), primitive.attributes.end(),
            [](const GLTF2::Attribute& attribute) {
                return attribute.attribute.type == GLTF2::AttributeType::POSITION;
            });
        pos != primitive.attributes.end()) {
        info.vertexCount = pos->accessor->count;
    }

    if (primitive.indices) {
        info.indexCount = primitive.indices->count;
        info.indexType = GetPrimitiveIndexType(primitive);
    }

    info.morphTargetCount = (uint32_t)primitive.targets.size();

    info.inputAssembly = ConvertGltf2InputAssembly(primitive.mode);

    return info;
}

string GatherErrorStrings(size_t primitiveIndex, const GLTF2::GLTFLoadDataResult& position,
    const GLTF2::GLTFLoadDataResult& normal, array_view<const GLTF2::GLTFLoadDataResult> texcoords,
    const GLTF2::GLTFLoadDataResult& tangent, const GLTF2::GLTFLoadDataResult& color,
    const GLTF2::GLTFLoadDataResult& joint, const GLTF2::GLTFLoadDataResult& weight)
{
    string error = "Failed to load primitive " + to_string(primitiveIndex) + '\n' + position.error + normal.error;
    for (const auto& tc : texcoords) {
        error += tc.error;
    }
    error += tangent.error + color.error + joint.error + weight.error + '\n';
    return error;
}

struct IndicesResult {
    GLTF2::GLTFLoadDataResult loadDataResult;
    bool primitiveRestart { false };
};

IndicesResult LoadIndices(GatherMeshDataResult& result, const GLTF2::MeshPrimitive& primitive, IndexType indexType,
    uint32_t loadedVertexCount)
{
    IndicesResult indicesLoadResult;
    if (primitive.indices) {
        if (indicesLoadResult.loadDataResult = LoadData(*primitive.indices); indicesLoadResult.loadDataResult.success) {
            ValidateIndices(indicesLoadResult.loadDataResult, loadedVertexCount, indicesLoadResult.primitiveRestart);
        }
        if (!indicesLoadResult.loadDataResult.success) {
            result.error += indicesLoadResult.loadDataResult.error;
            result.success = false;
            indicesLoadResult.loadDataResult = {};
        }
    }
    return indicesLoadResult;
}

void ProcessPrimitives(GatherMeshDataResult& result, uint32_t flags, array_view<const GLTF2::MeshPrimitive> primitives)
{
    // Feed primitive data for builder.
    for (size_t primitiveIndex = 0, count = primitives.size(); primitiveIndex < count; ++primitiveIndex) {
        const auto& primitive = primitives[primitiveIndex];
        const auto& importInfo = result.meshBuilder->GetSubmesh(primitiveIndex);

        // Load data.
        GLTF2::GLTFLoadDataResult position, normal, tangent, color, joint, weight;
        GLTF2::GLTFLoadDataResult texcoords[2];
        if (!LoadPrimitiveAttributeData(primitive, position, normal, texcoords, tangent, joint, weight, color, flags)) {
            result.error +=
                GatherErrorStrings(primitiveIndex, position, normal, texcoords, tangent, color, joint, weight);
            result.success = false;
            break;
        }

        uint32_t const loadedVertexCount = static_cast<uint32_t>(position.elementCount);

        auto fillDataBuffer = [](GLTF2::GLTFLoadDataResult& attribute) {
            return IMeshBuilder::DataBuffer {
                Convert(attribute.componentType, attribute.componentCount, attribute.normalized),
                static_cast<uint32_t>(attribute.elementSize),
                attribute.data,
            };
        };
        const IMeshBuilder::DataBuffer positions = fillDataBuffer(position);
        const IMeshBuilder::DataBuffer normals = fillDataBuffer(normal);
        const IMeshBuilder::DataBuffer texcoords0 = fillDataBuffer(texcoords[0]);
        const IMeshBuilder::DataBuffer texcoords1 = fillDataBuffer(texcoords[1]);
        const IMeshBuilder::DataBuffer tangents = fillDataBuffer(tangent);
        const IMeshBuilder::DataBuffer colors = fillDataBuffer(color);

        result.meshBuilder->SetVertexData(primitiveIndex, positions, normals, texcoords0, texcoords1, tangents, colors);

        // Process indices.
        IndicesResult indices = LoadIndices(result, primitive, importInfo.indexType, loadedVertexCount);
        if (!indices.loadDataResult.data.empty()) {
            const auto elementSize = indices.loadDataResult.elementSize;
            const IMeshBuilder::DataBuffer data { (elementSize == sizeof(uint32_t))
                                                      ? BASE_FORMAT_R32_UINT
                                                      : ((elementSize == sizeof(uint16_t)) ? BASE_FORMAT_R16_UINT
                                                                                           : BASE_FORMAT_R8_UINT),
                static_cast<uint32_t>(elementSize), { indices.loadDataResult.data } };
            result.meshBuilder->SetIndexData(primitiveIndex, data);
            if (indices.primitiveRestart) {
                result.meshBuilder->EnablePrimitiveRestart(primitiveIndex);
            }
        }

        // Set AABB.
        if (position.min.size() == 3 && position.max.size() == 3) {
            const Math::Vec3 min = { position.min[0], position.min[1], position.min[2] };
            const Math::Vec3 max = { position.max[0], position.max[1], position.max[2] };
            result.meshBuilder->SetAABB(primitiveIndex, min, max);
        } else {
            result.meshBuilder->CalculateAABB(primitiveIndex, positions);
        }

        // Process joints.
        if (!joint.data.empty() && (flags & CORE_GLTF_IMPORT_RESOURCE_SKIN)) {
            const IMeshBuilder::DataBuffer joints = fillDataBuffer(joint);
            const IMeshBuilder::DataBuffer weights = fillDataBuffer(weight);
            result.meshBuilder->SetJointData(primitiveIndex, joints, weights, positions);
        }
        // Process morphs.
        if (primitive.targets.size()) {
            GLTF2::GLTFLoadDataResult targetPosition, targetNormal, targetTangent;
            GenerateMorphTargets(primitive, importInfo, targetPosition, targetNormal, targetTangent);
            const IMeshBuilder::DataBuffer targetPositions = fillDataBuffer(targetPosition);
            const IMeshBuilder::DataBuffer targetNormals = fillDataBuffer(targetNormal);
            const IMeshBuilder::DataBuffer targetTangents = fillDataBuffer(targetTangent);

            result.meshBuilder->SetMorphTargetData(
                primitiveIndex, positions, normals, tangents, targetPositions, targetNormals, targetTangents);
        }
    }
}

GatherMeshDataResult GatherMeshData(const GLTF2::Mesh& mesh, const GLTFImportResult& importResult, uint32_t flags,
    const IMaterialComponentManager& materialManager, const IDevice& device, IEngine& engine)
{
    GatherMeshDataResult result;
    auto context = GetInstance<IRenderContext>(*engine.GetInterface<IClassRegister>(), UID_RENDER_CONTEXT);
    if (!context) {
        result.success = false;
        result.error = "RenderContext not found.";
        return result;
    }
    auto& shaderManager = device.GetShaderManager();
    const VertexInputDeclarationView vertexInputDeclaration =
        shaderManager.GetVertexInputDeclarationView(shaderManager.GetVertexInputDeclarationHandle(
            DefaultMaterialShaderConstants::VERTEX_INPUT_DECLARATION_FORWARD));

    result.meshBuilder.reset(static_cast<MeshBuilder*>(CreateInstance<IMeshBuilder>(*context, UID_MESH_BUILDER).get()));
    result.meshBuilder->Initialize(vertexInputDeclaration, mesh.primitives.size());

    // Create primitive import info for mesh builder.
    for (const auto& primitive : mesh.primitives) {
        // Add to builder.
        result.meshBuilder->AddSubmesh(CreatePrimitiveImportInfo(importResult, materialManager, primitive));
    }

    // Allocate memory for builder.
    result.meshBuilder->Allocate();

    // Feed primitive data for builder.
    ProcessPrimitives(result, flags, mesh.primitives);

    if (result.meshBuilder->GetVertexCount()) {
        result.meshBuilder->CreateGpuResources();
    }

    return result;
}

Entity ImportMesh(IEcs& ecs, const GatherMeshDataResult& gatherResult)
{
    // No vertices, which means we can't import mesh.
    if (gatherResult.meshBuilder->GetVertexCount() == 0) {
        return {};
    }
    auto meshEntity = gatherResult.meshBuilder->CreateMesh(ecs);
    return meshEntity;
}

string ResolveNodePath(GLTF2::Node const& node)
{
    string path;

    auto length = node.name.size();
    GLTF2::Node* parent = node.parent;
    while (parent) {
        length += parent->name.size() + 1U;
        parent = parent->parent;
    }

    path.resize(length);
    length -= node.name.size();
    const auto begin = path.begin();
    path.replace(begin + static_cast<string::difference_type>(length),
        begin + static_cast<string::difference_type>(length + node.name.size()), node.name);

    parent = node.parent;
    while (parent) {
        length -= 1U;
        path[length] = '/';
        length -= parent->name.size();
        path.replace(begin + static_cast<string::difference_type>(length),
            begin + static_cast<string::difference_type>(length + parent->name.size()), parent->name);
        parent = parent->parent;
    }

    return path;
}

bool BuildSkinIbmComponent(GLTF2::Skin const& skin, SkinIbmComponent& skinIbm)
{
    skinIbm.matrices.reserve(skin.joints.size());
    bool failed = false;
    bool useIdentityMatrix = true;
    if (skin.inverseBindMatrices) {
        GLTF2::GLTFLoadDataResult loadDataResult = GLTF2::LoadData(*skin.inverseBindMatrices);
        if (loadDataResult.success) {
            useIdentityMatrix = false;
            auto ibls = array_view(
                reinterpret_cast<Math::Mat4X4 const*>(loadDataResult.data.data()), loadDataResult.elementCount);
            skinIbm.matrices.append(ibls.begin(), ibls.end());
        }
    }
    if (failed) {
        return false;
    }

    if (useIdentityMatrix) {
        skinIbm.matrices.append(skin.joints.size(), Math::IDENTITY_4X4);
    }

    return true;
}

enum ImporterImageUsageFlags : uint32_t {
    IMAGE_USAGE_BASE_COLOR_BIT = (1 << 1),
    IMAGE_USAGE_METALLIC_ROUGHNESS_BIT = (1 << 2),
    IMAGE_USAGE_NORMAL_BIT = (1 << 3),
    IMAGE_USAGE_EMISSIVE_BIT = (1 << 4),
    IMAGE_USAGE_OCCLUSION_BIT = (1 << 5),
    IMAGE_USAGE_SPECULAR_GLOSSINESS_BIT = (1 << 6),
    IMAGE_USAGE_CLEARCOAT_BIT = (1 << 7),
    IMAGE_USAGE_CLEARCOAT_ROUGHNESS_BIT = (1 << 8),
    IMAGE_USAGE_SHEEN_COLOR_BIT = (1 << 9),
    IMAGE_USAGE_SHEEN_ROUGHNESS_BIT = (1 << 10),
    IMAGE_USAGE_SPECULAR_BIT = (1 << 11),
    IMAGE_USAGE_TRANSMISSION_BIT = (1 << 12),
    IMAGE_USAGE_SINGLE_CHANNEL = IMAGE_USAGE_OCCLUSION_BIT | IMAGE_USAGE_TRANSMISSION_BIT
};

inline bool operator==(const GLTF2::TextureInfo& info, const GLTF2::Image& image) noexcept
{
    return info.texture && info.texture->image == &image;
}

inline void BaseColorFlags(
    const GLTF2::Material& material, const GLTF2::Image& image, uint32_t& result, uint32_t& usage)
{
    if (material.metallicRoughness.baseColorTexture == image) {
        result |= (IImageLoaderManager::ImageLoaderFlags::IMAGE_LOADER_FORCE_SRGB_BIT |
                   IImageLoaderManager::ImageLoaderFlags::IMAGE_LOADER_PREMULTIPLY_ALPHA);
        usage |= IMAGE_USAGE_BASE_COLOR_BIT;
    }
}

inline void MetallicRoughnessFlags(
    const GLTF2::Material& material, const GLTF2::Image& image, uint32_t& result, uint32_t& usage)
{
    if (material.metallicRoughness.metallicRoughnessTexture == image) {
        result |= IImageLoaderManager::ImageLoaderFlags::IMAGE_LOADER_FORCE_LINEAR_RGB_BIT;
        usage |= IMAGE_USAGE_METALLIC_ROUGHNESS_BIT;
    }
}

inline void NormalFlags(const GLTF2::Material& material, const GLTF2::Image& image, uint32_t& result, uint32_t& usage)
{
    if (material.normalTexture.textureInfo == image) {
        result |= IImageLoaderManager::ImageLoaderFlags::IMAGE_LOADER_FORCE_LINEAR_RGB_BIT;
        usage |= IMAGE_USAGE_NORMAL_BIT;
    }
}

inline void EmissiveFlags(const GLTF2::Material& material, const GLTF2::Image& image, uint32_t& result, uint32_t& usage)
{
    if (material.emissiveTexture == image) {
        result |= IImageLoaderManager::ImageLoaderFlags::IMAGE_LOADER_FORCE_SRGB_BIT;
        usage |= IMAGE_USAGE_EMISSIVE_BIT;
    }
}

inline void OcclusionFlags(
    const GLTF2::Material& material, const GLTF2::Image& image, uint32_t& result, uint32_t& usage)
{
    if (material.occlusionTexture.textureInfo == image) {
        result |= IImageLoaderManager::ImageLoaderFlags::IMAGE_LOADER_FORCE_LINEAR_RGB_BIT;
        usage |= IMAGE_USAGE_OCCLUSION_BIT;
    }
}

#if defined(GLTF2_EXTENSION_KHR_MATERIALS_PBRSPECULARGLOSSINESS)
inline void SpecularGlossinessFlags(
    const GLTF2::Material& material, const GLTF2::Image& image, uint32_t& result, uint32_t& usage)
{
    if (material.specularGlossiness.specularGlossinessTexture == image) {
        result |= IImageLoaderManager::ImageLoaderFlags::IMAGE_LOADER_FORCE_SRGB_BIT;
        usage |= IMAGE_USAGE_SPECULAR_GLOSSINESS_BIT;
    }
}
#endif

#if defined(GLTF2_EXTENSION_KHR_MATERIALS_CLEARCOAT)
inline void ClearcoatFlags(
    const GLTF2::Material& material, const GLTF2::Image& image, uint32_t& result, uint32_t& usage)
{
    if (material.clearcoat.texture == image) {
        result |= IImageLoaderManager::ImageLoaderFlags::IMAGE_LOADER_FORCE_LINEAR_RGB_BIT;
        usage |= IMAGE_USAGE_CLEARCOAT_BIT;
    }
}

inline void ClearcoatRoughnessFlags(
    const GLTF2::Material& material, const GLTF2::Image& image, uint32_t& result, uint32_t& usage)
{
    if (material.clearcoat.roughnessTexture == image) {
        result |= IImageLoaderManager::ImageLoaderFlags::IMAGE_LOADER_FORCE_LINEAR_RGB_BIT;
        usage |= IMAGE_USAGE_CLEARCOAT_ROUGHNESS_BIT;
    }
}

inline void ClearcoatNormalFlags(
    const GLTF2::Material& material, const GLTF2::Image& image, uint32_t& result, uint32_t& usage)
{
    if (material.clearcoat.normalTexture.textureInfo == image) {
        result |= IImageLoaderManager::ImageLoaderFlags::IMAGE_LOADER_FORCE_LINEAR_RGB_BIT;
        usage |= IMAGE_USAGE_NORMAL_BIT;
    }
}
#endif

#if defined(GLTF2_EXTENSION_KHR_MATERIALS_SHEEN)
inline void SheenFlags(const GLTF2::Material& material, const GLTF2::Image& image, uint32_t& result, uint32_t& usage)
{
    if (material.sheen.texture == image) {
        result |= IImageLoaderManager::ImageLoaderFlags::IMAGE_LOADER_FORCE_SRGB_BIT;
        usage |= IMAGE_USAGE_SHEEN_COLOR_BIT;
    }
}

inline void SheenRoughnessFlags(
    const GLTF2::Material& material, const GLTF2::Image& image, uint32_t& result, uint32_t& usage)
{
    if (material.sheen.roughnessTexture == image) {
        if (!(usage & IMAGE_USAGE_SHEEN_COLOR_BIT)) {
            result |= IImageLoaderManager::ImageLoaderFlags::IMAGE_LOADER_FORCE_LINEAR_RGB_BIT;
        }
        usage |= IMAGE_USAGE_SHEEN_ROUGHNESS_BIT;
    }
}
#endif

#if defined(GLTF2_EXTENSION_KHR_MATERIALS_SPECULAR)
inline void SpecularColorFlags(
    const GLTF2::Material& material, const GLTF2::Image& image, uint32_t& result, uint32_t& usage)
{
    if (material.specular.colorTexture == image) {
        result |= IImageLoaderManager::ImageLoaderFlags::IMAGE_LOADER_FORCE_SRGB_BIT;
        usage |= IMAGE_USAGE_SPECULAR_BIT;
    }
}

inline void SpecularStrengthFlags(
    const GLTF2::Material& material, const GLTF2::Image& image, uint32_t& result, uint32_t& usage)
{
    if (material.specular.texture == image) {
        if (!(usage & IMAGE_USAGE_SPECULAR_BIT)) {
            result |= IImageLoaderManager::ImageLoaderFlags::IMAGE_LOADER_FORCE_LINEAR_RGB_BIT;
        }
        usage |= IMAGE_USAGE_SPECULAR_BIT;
    }
}
#endif

#if defined(GLTF2_EXTENSION_KHR_MATERIALS_TRANSMISSION)
inline void TransmissionFlags(
    const GLTF2::Material& material, const GLTF2::Image& image, uint32_t& result, uint32_t& usage)
{
    if (material.transmission.texture == image) {
        result |= IImageLoaderManager::ImageLoaderFlags::IMAGE_LOADER_FORCE_LINEAR_RGB_BIT;
        usage |= IMAGE_USAGE_TRANSMISSION_BIT;
    }
}
#endif

uint32_t ResolveImageLoadFlags(
    GLTF2::Image const& image, GLTF2::Data const& data, const ColorSpaceFlags colorSpaceFlags)
{
    // Resolve whether image should be imported as SRGB or LINEAR.
    uint32_t result = 0;
    // Resolve in which parts of material this texture has been used.
    uint32_t usage = 0;

    // Generating mipmaps for all textures (if not already contained in the image).
    result |= IImageLoaderManager::ImageLoaderFlags::IMAGE_LOADER_GENERATE_MIPS;

    for (const auto& material : data.materials) {
        BaseColorFlags(*material, image, result, usage);
        MetallicRoughnessFlags(*material, image, result, usage);
        NormalFlags(*material, image, result, usage);
        EmissiveFlags(*material, image, result, usage);
        OcclusionFlags(*material, image, result, usage);

#if defined(GLTF2_EXTENSION_KHR_MATERIALS_PBRSPECULARGLOSSINESS)
        SpecularGlossinessFlags(*material, image, result, usage);
#endif
#if defined(GLTF2_EXTENSION_KHR_MATERIALS_CLEARCOAT)
        ClearcoatFlags(*material, image, result, usage);
        ClearcoatRoughnessFlags(*material, image, result, usage);
        ClearcoatNormalFlags(*material, image, result, usage);
#endif
#if defined(GLTF2_EXTENSION_KHR_MATERIALS_SHEEN)
        SheenFlags(*material, image, result, usage);
        SheenRoughnessFlags(*material, image, result, usage);
#endif
#if defined(GLTF2_EXTENSION_KHR_MATERIALS_SPECULAR)
        SpecularColorFlags(*material, image, result, usage);
        SpecularStrengthFlags(*material, image, result, usage);
#endif
#if defined(GLTF2_EXTENSION_KHR_MATERIALS_TRANSMISSION)
        TransmissionFlags(*material, image, result, usage);
#endif
        // possible color space conversions
        if (colorSpaceFlags & ColorSpaceFlagBits::COLOR_SPACE_SRGB_AS_LINEAR_BIT) {
            // remove srgb
            result &= (~IImageLoaderManager::ImageLoaderFlags::IMAGE_LOADER_FORCE_SRGB_BIT);
            // add forcing of linear
            result |= IImageLoaderManager::ImageLoaderFlags::IMAGE_LOADER_FORCE_LINEAR_RGB_BIT;
        }
    }

    // In case the texture is only used in occlusion channel, we can convert it to grayscale R8.
    if ((usage & (IMAGE_USAGE_SINGLE_CHANNEL)) && !(usage & ~(IMAGE_USAGE_SINGLE_CHANNEL))) {
        result |= IImageLoaderManager::ImageLoaderFlags::IMAGE_LOADER_FORCE_GRAYSCALE_BIT;
    }

    const bool isSRGB = result & IImageLoaderManager::ImageLoaderFlags::IMAGE_LOADER_FORCE_SRGB_BIT;
    const bool isLinear = result & IImageLoaderManager::ImageLoaderFlags::IMAGE_LOADER_FORCE_LINEAR_RGB_BIT;
    if (isSRGB && isLinear) {
        // In case the texture has both SRGB & LINEAR set, default to SRGB and print a warning.
        result &= ~IImageLoaderManager::ImageLoaderFlags::IMAGE_LOADER_FORCE_LINEAR_RGB_BIT;

        if (GLTF2::IsDataURI(image.uri)) {
            CORE_LOG_W("Unable to resolve color space for Image, defaulting to SRGB.");
        } else {
            CORE_LOG_W("Unable to resolve color space for Image %s, defaulting to SRGB.", image.uri.c_str());
        }
    }

    return result;
}

EntityReference ResolveSampler(
    GLTF2::Texture const& texture, GLTF2::Data const& data, GLTFImportResult const& importResult)
{
    if (texture.sampler) {
        const size_t index = FindIndex(data.samplers, texture.sampler);
        if (index != GLTF2::GLTF_INVALID_INDEX) {
            return importResult.data.samplers[index];
        }
    }

    return {};
}

inline EntityReference ResolveSampler(
    const GLTF2::TextureInfo& textureInfo, GLTF2::Data const& data, GLTFImportResult const& importResult)
{
    return textureInfo.texture ? ResolveSampler(*textureInfo.texture, data, importResult) : EntityReference {};
}

// Textures
IImageLoaderManager::LoadResult GatherImageData(GLTF2::Image& image, GLTF2::Data const& data, IFileManager& fileManager,
    IImageLoaderManager& imageManager, uint32_t loadFlags, ColorSpaceFlags colorSpaceFlags)
{
    vector<uint8_t> raw;

    const GLTF2::BufferView* bufferView = image.bufferView;

    if (bufferView && image.type != GLTF2::MimeType::INVALID) {
        if (bufferView->data) {
            raw.append(image.bufferView->data, bufferView->data + bufferView->byteLength);
        }
    } else if (image.uri.size()) {
        auto extension = GetImageExtension(image.type);
        const auto result = GLTF2::LoadUri(image.uri, "image", data.filepath, fileManager, extension, raw);
        switch (result) {
            case GLTF2::URI_LOAD_FAILED_TO_DECODE_BASE64:
                return IImageLoaderManager::LoadResult { false, "Base64 decoding failed.", nullptr };

            case GLTF2::URI_LOAD_FAILED_TO_READ_FILE:
                return IImageLoaderManager::LoadResult { false, "Failed to read file.", nullptr };

            case GLTF2::URI_LOAD_FAILED_INVALID_MIME_TYPE:
                return IImageLoaderManager::LoadResult { false, "Image data is not image type.", nullptr };

            default:
            case GLTF2::URI_LOAD_SUCCESS:
                break;
        }
    }

    // Resolve image usage and determine flags.
    const uint32_t flags = ResolveImageLoadFlags(image, data, colorSpaceFlags) | loadFlags;

    array_view<const uint8_t> rawdata { raw };
    return imageManager.LoadImage(rawdata, flags);
}

void ResolveReferencedImages(GLTF2::Data const& data, vector<bool>& imageLoadingRequred)
{
    // loader shouldn't add nullptrs to Data::textures or Texture::image, but checking still
    for (const auto& texture : data.textures) {
        if (!texture) {
            continue;
        }
        const size_t index = FindIndex(data.images, texture->image);
        if ((index != GLTF2::GLTF_INVALID_INDEX) && (texture->image)) {
            imageLoadingRequred[index] = true;
        }
    }

#if defined(GLTF2_EXTENSION_EXT_LIGHTS_IMAGE_BASED)
    // Find image references from image based lights.
    for (const auto& light : data.imageBasedLights) {
        if (light && (light->skymapImage != GLTF2::GLTF_INVALID_INDEX) && (light->skymapImage < data.images.size()) &&
            (data.images[light->skymapImage])) {
            imageLoadingRequred[light->skymapImage] = true;
        }
        if (light && (light->specularCubeImage != GLTF2::GLTF_INVALID_INDEX) &&
            (light->specularCubeImage < data.images.size()) && (data.images[light->specularCubeImage])) {
            imageLoadingRequred[light->specularCubeImage] = true;
        }
    }
#endif
}

AnimationTrackComponent::Interpolation ConvertAnimationInterpolation(GLTF2::AnimationInterpolation mode)
{
    switch (mode) {
        case GLTF2::AnimationInterpolation::INVALID:
            CORE_ASSERT(false);
            break;
        case GLTF2::AnimationInterpolation::STEP:
            return AnimationTrackComponent::Interpolation::STEP;
        case GLTF2::AnimationInterpolation::LINEAR:
            return AnimationTrackComponent::Interpolation::LINEAR;
        case GLTF2::AnimationInterpolation::SPLINE:
            return AnimationTrackComponent::Interpolation::SPLINE;
        default:
            break;
    }

    return AnimationTrackComponent::Interpolation::LINEAR;
}

template<class T>
void CopyFrames(GLTF2::GLTFLoadDataResult const& animationFrameDataResult, vector<T>& destination)
{
    destination.resize(animationFrameDataResult.elementCount);
    if (animationFrameDataResult.componentType == GLTF2::ComponentType::FLOAT) {
        CORE_ASSERT(animationFrameDataResult.elementSize == sizeof(T));

        const size_t dataSizeInBytes = animationFrameDataResult.elementSize * animationFrameDataResult.elementCount;
        if (!CloneData(destination.data(), destination.size() * sizeof(T), animationFrameDataResult.data.data(),
                dataSizeInBytes)) {
            CORE_LOG_E("Copying of raw framedata failed.");
        }
    } else {
        // Convert data.
        if (animationFrameDataResult.normalized) {
            ConvertNormalizedDataToFloat(animationFrameDataResult, reinterpret_cast<float*>(destination.data()));
        } else {
            ConvertDataToFloat(animationFrameDataResult, reinterpret_cast<float*>(destination.data()));
        }
    }
}

template<>
void CopyFrames(GLTF2::GLTFLoadDataResult const& animationFrameDataResult, vector<bool>& destination)
{
    destination.resize(animationFrameDataResult.elementCount);
    if (animationFrameDataResult.componentType == GLTF2::ComponentType::BYTE ||
        animationFrameDataResult.componentType == GLTF2::ComponentType::UNSIGNED_BYTE) {
        CORE_ASSERT(animationFrameDataResult.elementSize == sizeof(bool));

        const size_t dataSizeInBytes = animationFrameDataResult.elementSize * animationFrameDataResult.elementCount;
        if (!CloneData(destination.data(), destination.size() * sizeof(bool), animationFrameDataResult.data.data(),
                dataSizeInBytes)) {
            CORE_LOG_E("Copying of raw framedata failed.");
        }
    } else {
        // Convert data.
        ConvertDataToBool(animationFrameDataResult, destination.data());
    }
}

bool BuildAnimationInput(GLTF2::Data const& data, IFileManager& fileManager, GLTF2::Accessor& inputAccessor,
    AnimationInputComponent& inputComponent)
{
    const GLTF2::GLTFLoadDataResult animationInputDataResult = LoadData(inputAccessor);
    if (animationInputDataResult.success) {
        // Copy timestamps.
        inputComponent.timestamps.reserve(animationInputDataResult.elementCount);
        const float* timeStamps =
            reinterpret_cast<const float*>(reinterpret_cast<uintptr_t>(animationInputDataResult.data.data()));
        inputComponent.timestamps.append(timeStamps, timeStamps + animationInputDataResult.elementCount);
    }

    return animationInputDataResult.success;
}

template<typename ReadType>
void AppendAnimationOutputData(uint64_t outputTypeHash, const GLTF2::GLTFLoadDataResult& animationOutputDataResult,
    AnimationOutputComponent& outputComponent)
{
    outputComponent.type = outputTypeHash;
    vector<ReadType> positions;
    CopyFrames(animationOutputDataResult, positions);
    const auto dataView = array_view(reinterpret_cast<const uint8_t*>(positions.data()), positions.size_in_bytes());
    outputComponent.data.append(dataView.cbegin(), dataView.cend());
}

bool BuildAnimationOutput(GLTF2::Data const& data, IFileManager& fileManager, GLTF2::Accessor& outputAccessor,
    GLTF2::AnimationPath path, AnimationOutputComponent& outputComponent)
{
    const GLTF2::GLTFLoadDataResult animationOutputDataResult = LoadData(outputAccessor);
    if (animationOutputDataResult.success) {
        switch (path) {
            case GLTF2::AnimationPath::TRANSLATION:
                AppendAnimationOutputData<Math::Vec3>(PropertyType::VEC3_T, animationOutputDataResult, outputComponent);
                break;

            case GLTF2::AnimationPath::ROTATION:
                AppendAnimationOutputData<Math::Vec4>(PropertyType::QUAT_T, animationOutputDataResult, outputComponent);
                break;

            case GLTF2::AnimationPath::SCALE:
                AppendAnimationOutputData<Math::Vec3>(PropertyType::VEC3_T, animationOutputDataResult, outputComponent);
                break;

            case GLTF2::AnimationPath::WEIGHTS:
                AppendAnimationOutputData<float>(
                    PropertyType::FLOAT_VECTOR_T, animationOutputDataResult, outputComponent);
                break;

            case GLTF2::AnimationPath::VISIBLE:
                AppendAnimationOutputData<bool>(PropertyType::BOOL_T, animationOutputDataResult, outputComponent);
                break;

            case GLTF2::AnimationPath::OPACITY:
                AppendAnimationOutputData<float>(PropertyType::FLOAT_T, animationOutputDataResult, outputComponent);
                break;

            case GLTF2::AnimationPath::INVALID:
            default:
                CORE_LOG_W("Animation.channel.path type %d not implemented", static_cast<int>(path));
                break;
        }
    }

    return animationOutputDataResult.success;
}

#if defined(GLTF2_EXTENSION_KHR_TEXTURE_TRANSFORM)
void FillTextureTransform(const GLTF2::TextureInfo& textureInfo, MaterialComponent::TextureTransform& desc)
{
    const auto& transform = textureInfo.transform;
    desc.translation = transform.offset;
    desc.rotation = transform.rotation;
    desc.scale = transform.scale;
}
#endif

void FillTextureParams(const GLTF2::TextureInfo& textureInfo, const GLTFImportResult& importResult,
    const GLTF2::Data& data, IEntityManager& entityManager, MaterialComponent& desc,
    MaterialComponent::TextureIndex index)
{
    desc.textures[index].image = GetImportedTextureHandle(importResult, textureInfo.index);
    if (textureInfo.texture) {
        desc.textures[index].sampler = ResolveSampler(*textureInfo.texture, data, importResult);
        desc.useTexcoordSetBit |= static_cast<uint32_t>((textureInfo.texCoordIndex == 1)) << index;
#if defined(GLTF2_EXTENSION_KHR_TEXTURE_TRANSFORM)
        FillTextureTransform(textureInfo, desc.textures[index].transform);
#endif
    }
}

RenderHandleReference ImportTexture(const string_view uri, IImageContainer::Ptr image,
    IRenderDataStoreDefaultStaging& staging, IGpuResourceManager& gpuResourceManager)
{
    RenderHandleReference imageHandle;
    if (!image) {
        return imageHandle;
    }
    // return if image created already with the uri
    imageHandle = gpuResourceManager.GetImageHandle(uri);
    if (imageHandle) {
        return imageHandle;
    }

    const auto& imageDesc = image->GetImageDesc();
    const auto& subImageDescs = image->GetBufferImageCopies();
    const auto data = image->GetData();

    // Create image according to the image container's description. (expects that conversion handles everything)
    const GpuImageDesc gpuImageDesc = gpuResourceManager.CreateGpuImageDesc(imageDesc);
    imageHandle = gpuResourceManager.Create(uri, gpuImageDesc);

    if (imageHandle) {
        // Create buffer for uploading image data
        GpuBufferDesc gpuBufferDesc;
        gpuBufferDesc.usageFlags = BufferUsageFlagBits::CORE_BUFFER_USAGE_TRANSFER_SRC_BIT;
        gpuBufferDesc.memoryPropertyFlags = MemoryPropertyFlagBits::CORE_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
                                            MemoryPropertyFlagBits::CORE_MEMORY_PROPERTY_HOST_COHERENT_BIT;
        gpuBufferDesc.engineCreationFlags =
            EngineBufferCreationFlagBits::CORE_ENGINE_BUFFER_CREATION_CREATE_IMMEDIATE |
            EngineBufferCreationFlagBits::CORE_ENGINE_BUFFER_CREATION_MAP_OUTSIDE_RENDERER |
            EngineBufferCreationFlagBits::CORE_ENGINE_BUFFER_CREATION_DEFERRED_DESTROY;
        gpuBufferDesc.byteSize = static_cast<uint32_t>(data.size_bytes());
        auto bufferHandle = gpuResourceManager.Create(gpuBufferDesc);
        // Ideally ImageLoader would decode directly to the buffer to save one copy.
        if (auto buffer = static_cast<uint8_t*>(gpuResourceManager.MapBufferMemory(bufferHandle)); buffer) {
            const auto count = Math::min(static_cast<uint32_t>(data.size_bytes()), gpuBufferDesc.byteSize);
            std::copy(data.data(), data.data() + count, buffer);
        }
        gpuResourceManager.UnmapBuffer(bufferHandle);

        // Gather copy operations for all the sub images (mip levels, cube faces)
        vector<BufferImageCopy> copies;
        copies.reserve(subImageDescs.size());
        for (const auto& subImageDesc : subImageDescs) {
            const BufferImageCopy bufferImageCopy {
                subImageDesc.bufferOffset,      // bufferOffset
                subImageDesc.bufferRowLength,   // bufferRowLength
                subImageDesc.bufferImageHeight, // bufferImageHeight
                {
                    CORE_IMAGE_ASPECT_COLOR_BIT,                                // imageAspectFlags
                    subImageDesc.mipLevel,                                      // mipLevel
                    0,                                                          // baseArrayLayer
                    subImageDesc.layerCount,                                    // layerCount
                },                                                              // imageSubresource
                {},                                                             // imageOffset
                { subImageDesc.width, subImageDesc.height, subImageDesc.depth } // imageExtent
            };
            copies.push_back(bufferImageCopy);
        }
        staging.CopyBufferToImage(bufferHandle, imageHandle, copies);
    } else {
        CORE_LOG_W("Creating an import image failed (format:%u, width:%u, height:%u)",
            static_cast<uint32_t>(gpuImageDesc.format), gpuImageDesc.width, gpuImageDesc.height);
    }
    return imageHandle;
}

void FillMetallicRoughness(MaterialComponent& desc, const GLTFImportResult& importResult, const GLTF2::Data& data,
    const GLTF2::Material& gltfMaterial, IEntityManager& em)
{
    desc.type = MaterialComponent::Type::METALLIC_ROUGHNESS;
    FillTextureParams(gltfMaterial.metallicRoughness.baseColorTexture, importResult, data, em, desc,
        MaterialComponent::TextureIndex::BASE_COLOR);
    desc.textures[MaterialComponent::TextureIndex::BASE_COLOR].factor = gltfMaterial.metallicRoughness.baseColorFactor;

    // Metallic-roughness.
    FillTextureParams(gltfMaterial.metallicRoughness.metallicRoughnessTexture, importResult, data, em, desc,
        MaterialComponent::TextureIndex::MATERIAL);
    desc.textures[MaterialComponent::TextureIndex::MATERIAL].factor.y = gltfMaterial.metallicRoughness.roughnessFactor;
    desc.textures[MaterialComponent::TextureIndex::MATERIAL].factor.z = gltfMaterial.metallicRoughness.metallicFactor;
}

void FillSpecularGlossiness(MaterialComponent& desc, const GLTFImportResult& importResult, const GLTF2::Data& data,
    const GLTF2::Material& gltfMaterial, IEntityManager& em)
{
    desc.type = MaterialComponent::Type::SPECULAR_GLOSSINESS;
#if defined(GLTF2_EXTENSION_KHR_MATERIALS_PBRSPECULARGLOSSINESS)
    FillTextureParams(gltfMaterial.specularGlossiness.diffuseTexture, importResult, data, em, desc,
        MaterialComponent::TextureIndex::BASE_COLOR);
    desc.textures[MaterialComponent::TextureIndex::BASE_COLOR].factor = gltfMaterial.specularGlossiness.diffuseFactor;

    // Glossiness.
    FillTextureParams(gltfMaterial.specularGlossiness.specularGlossinessTexture, importResult, data, em, desc,
        MaterialComponent::TextureIndex::MATERIAL);
    desc.textures[MaterialComponent::TextureIndex::MATERIAL].factor = { gltfMaterial.specularGlossiness.specularFactor,
        gltfMaterial.specularGlossiness.glossinessFactor };
#endif
}

void FillUnlit(MaterialComponent& desc, const GLTFImportResult& importResult, const GLTF2::Data& data,
    const GLTF2::Material& gltfMaterial, IEntityManager& em)
{
    desc.type = MaterialComponent::Type::UNLIT;

    FillTextureParams(gltfMaterial.metallicRoughness.baseColorTexture, importResult, data, em, desc,
        MaterialComponent::TextureIndex::BASE_COLOR);
    desc.textures[MaterialComponent::TextureIndex::BASE_COLOR].factor = gltfMaterial.metallicRoughness.baseColorFactor;
}

void FillClearcoat(MaterialComponent& desc, const GLTFImportResult& importResult, const GLTF2::Data& data,
    const GLTF2::Material& gltfMaterial, IEntityManager& em)
{
#if defined(GLTF2_EXTENSION_KHR_MATERIALS_CLEARCOAT) || defined(GLTF2_EXTRAS_CLEAR_COAT_MATERIAL)
    // Clearcoat.
    desc.textures[MaterialComponent::TextureIndex::CLEARCOAT].factor.x = gltfMaterial.clearcoat.factor;
    FillTextureParams(
        gltfMaterial.clearcoat.texture, importResult, data, em, desc, MaterialComponent::TextureIndex::CLEARCOAT);
    desc.textures[MaterialComponent::TextureIndex::CLEARCOAT_ROUGHNESS].factor.y = gltfMaterial.clearcoat.roughness;
    FillTextureParams(gltfMaterial.clearcoat.roughnessTexture, importResult, data, em, desc,
        MaterialComponent::TextureIndex::CLEARCOAT_ROUGHNESS);
    FillTextureParams(gltfMaterial.clearcoat.normalTexture.textureInfo, importResult, data, em, desc,
        MaterialComponent::TextureIndex::CLEARCOAT_NORMAL);
    desc.textures[MaterialComponent::TextureIndex::CLEARCOAT_NORMAL].factor.x =
        gltfMaterial.clearcoat.normalTexture.scale;
#endif
}

void FillIor(MaterialComponent& desc, const GLTFImportResult& importResult, const GLTF2::Data& data,
    const GLTF2::Material& gltfMaterial, IEntityManager& em)
{
#if defined(GLTF2_EXTENSION_KHR_MATERIALS_IOR)
    // IOR.
    if (gltfMaterial.ior.ior != 1.5f) {
        auto reflectance = (gltfMaterial.ior.ior - 1.f) / (gltfMaterial.ior.ior + 1.f);
        desc.textures[MaterialComponent::TextureIndex::MATERIAL].factor.w = reflectance * reflectance;
    }
#endif
}

void FillSheen(MaterialComponent& desc, const GLTFImportResult& importResult, const GLTF2::Data& data,
    const GLTF2::Material& gltfMaterial, IEntityManager& em)
{
#if defined(GLTF2_EXTENSION_KHR_MATERIALS_SHEEN)
    // Sheen.
    desc.textures[MaterialComponent::TextureIndex::SHEEN].factor = Math::Vec4(gltfMaterial.sheen.factor, 0.f);
    FillTextureParams(gltfMaterial.sheen.texture, importResult, data, em, desc, MaterialComponent::TextureIndex::SHEEN);
    if (gltfMaterial.sheen.roughnessTexture.texture) {
        CORE_LOG_W("Sheen roughness mapping not supported by gltf2 importer");
    }
    // to sheen alpha
    desc.textures[MaterialComponent::TextureIndex::SHEEN].factor.w = gltfMaterial.sheen.roughness;
#endif
}

void FillSpecular(MaterialComponent& desc, const GLTFImportResult& importResult, const GLTF2::Data& data,
    const GLTF2::Material& gltfMaterial, IEntityManager& em)
{
#if defined(GLTF2_EXTENSION_KHR_MATERIALS_SPECULAR)
    // Specular.
    desc.textures[MaterialComponent::TextureIndex::SPECULAR].factor =
        Math::Vec4(gltfMaterial.specular.color, gltfMaterial.specular.factor);
    if (gltfMaterial.specular.texture.index != GLTF2::GLTF_INVALID_INDEX &&
        gltfMaterial.specular.colorTexture.index == GLTF2::GLTF_INVALID_INDEX) {
        FillTextureParams(
            gltfMaterial.specular.texture, importResult, data, em, desc, MaterialComponent::TextureIndex::SPECULAR);
    } else if (gltfMaterial.specular.texture.index == GLTF2::GLTF_INVALID_INDEX &&
               gltfMaterial.specular.colorTexture.index != GLTF2::GLTF_INVALID_INDEX) {
        FillTextureParams(gltfMaterial.specular.colorTexture, importResult, data, em, desc,
            MaterialComponent::TextureIndex::SPECULAR);
    } else if (gltfMaterial.specular.texture.index != gltfMaterial.specular.colorTexture.index) {
        CORE_LOG_W("Separate specular strength and color textures are not supported!");
        FillTextureParams(gltfMaterial.specular.colorTexture, importResult, data, em, desc,
            MaterialComponent::TextureIndex::SPECULAR);
    } else {
        FillTextureParams(gltfMaterial.specular.colorTexture, importResult, data, em, desc,
            MaterialComponent::TextureIndex::SPECULAR);
    }
#endif
}

void FillTransmission(MaterialComponent& desc, const GLTFImportResult& importResult, const GLTF2::Data& data,
    const GLTF2::Material& gltfMaterial, IEntityManager& em)
{
#if defined(GLTF2_EXTENSION_KHR_MATERIALS_TRANSMISSION)
    // Transmission.
    desc.textures[MaterialComponent::TextureIndex::TRANSMISSION].factor.x = gltfMaterial.transmission.factor;
    FillTextureParams(
        gltfMaterial.transmission.texture, importResult, data, em, desc, MaterialComponent::TextureIndex::TRANSMISSION);
#endif
}

void SelectShaders(MaterialComponent& desc, const GLTF2::Material& gltfMaterial,
    const GLTF2::GLTF2Importer::DefaultMaterialShaderData& dmShaderData)
{
    // Shadow casting is removed from blend modes by default.
    // Transmission over writes the gltf material blend mode.
    if (desc.textures[MaterialComponent::TextureIndex::TRANSMISSION].factor.x > 0.0f) {
        desc.materialShader.shader = dmShaderData.blend.shader;
        // no support for double-sideness with default material and transmission
        desc.materialShader.graphicsState = dmShaderData.blend.gfxState;
        if (gltfMaterial.alphaMode == GLTF2::AlphaMode::BLEND) { // blending -> no shadows
            desc.materialLightingFlags &= (~MaterialComponent::LightingFlagBits::SHADOW_CASTER_BIT);
        }
    } else if (gltfMaterial.alphaMode == GLTF2::AlphaMode::BLEND) {
        desc.materialShader.shader = dmShaderData.blend.shader;
        desc.materialShader.graphicsState =
            gltfMaterial.doubleSided ? dmShaderData.blend.gfxStateDoubleSided : dmShaderData.blend.gfxState;
        desc.materialLightingFlags &= (~MaterialComponent::LightingFlagBits::SHADOW_CASTER_BIT);
    } else {
        // opaque materials are expected to have alpha value of 1.0f based on the blend state
        desc.textures[MaterialComponent::TextureIndex::BASE_COLOR].factor.w = 1.0f;
        desc.materialShader.shader = dmShaderData.opaque.shader;
        desc.materialShader.graphicsState =
            gltfMaterial.doubleSided ? dmShaderData.opaque.gfxStateDoubleSided : dmShaderData.opaque.gfxState;
        // default materials support instancing with opaque materials.
        desc.extraRenderingFlags |= MaterialComponent::ExtraRenderingFlagBits::ALLOW_GPU_INSTANCING_BIT;
    }
    // shadow shader data
    if (desc.materialLightingFlags & MaterialComponent::LightingFlagBits::SHADOW_CASTER_BIT) {
        desc.depthShader.shader = dmShaderData.depth.shader;
        desc.depthShader.graphicsState =
            gltfMaterial.doubleSided ? dmShaderData.depth.gfxStateDoubleSided : dmShaderData.depth.gfxState;
    }
}

bool ImportMaterial(GLTFImportResult const& importResult, GLTF2::Data const& data, GLTF2::Material const& gltfMaterial,
    const Entity materialEntity, IMaterialComponentManager& materialManager,
    IGpuResourceManager const& gpuResourceManager, const GLTF2::GLTF2Importer::DefaultMaterialShaderData& dmShaderData)
{
    auto materialHandle = materialManager.Write(materialEntity);
    if (!materialHandle) {
        return false;
    }
    auto& desc = *materialHandle;
    auto& ecs = materialManager.GetEcs();
    auto& em = ecs.GetEntityManager();
    if (gltfMaterial.type == GLTF2::Material::Type::MetallicRoughness) {
        FillMetallicRoughness(desc, importResult, data, gltfMaterial, em);
    } else if (gltfMaterial.type == GLTF2::Material::Type::SpecularGlossiness) {
        FillSpecularGlossiness(desc, importResult, data, gltfMaterial, em);
    } else if (gltfMaterial.type == GLTF2::Material::Type::Unlit) {
        FillUnlit(desc, importResult, data, gltfMaterial, em);
    }

    // Normal texture.
    FillTextureParams(
        gltfMaterial.normalTexture.textureInfo, importResult, data, em, desc, MaterialComponent::TextureIndex::NORMAL);
    desc.textures[MaterialComponent::TextureIndex::NORMAL].factor.x = gltfMaterial.normalTexture.scale;

    // Occlusion texture.
    FillTextureParams(
        gltfMaterial.occlusionTexture.textureInfo, importResult, data, em, desc, MaterialComponent::TextureIndex::AO);
    desc.textures[MaterialComponent::TextureIndex::AO].factor.x = gltfMaterial.occlusionTexture.strength;

    // Emissive texture.
    FillTextureParams(
        gltfMaterial.emissiveTexture, importResult, data, em, desc, MaterialComponent::TextureIndex::EMISSIVE);
    desc.textures[MaterialComponent::TextureIndex::EMISSIVE].factor = gltfMaterial.emissiveFactor;

    // Handle material extension
    FillClearcoat(desc, importResult, data, gltfMaterial, em);
    FillIor(desc, importResult, data, gltfMaterial, em);
    FillSheen(desc, importResult, data, gltfMaterial, em);
    FillSpecular(desc, importResult, data, gltfMaterial, em);
    FillTransmission(desc, importResult, data, gltfMaterial, em);

    // Always receive and cast shadows. (Modified with blend modes below)
    desc.materialLightingFlags |= MaterialComponent::LightingFlagBits::SHADOW_RECEIVER_BIT;
    desc.materialLightingFlags |= MaterialComponent::LightingFlagBits::SHADOW_CASTER_BIT;

    if (gltfMaterial.alphaMode == GLTF2::AlphaMode::MASK) {
        // we "enable" if it's set
        desc.alphaCutoff = gltfMaterial.alphaCutoff;
    }

    SelectShaders(desc, gltfMaterial, dmShaderData);
    return true;
}

void ConvertToCoreFilter(GLTF2::FilterMode mode, Filter& outFilter, Filter& outMipmapMode)
{
    switch (mode) {
        case GLTF2::FilterMode::NEAREST:
            outFilter = CORE_FILTER_NEAREST;
            outMipmapMode = CORE_FILTER_NEAREST;
            break;

        default:
        case GLTF2::FilterMode::LINEAR:
            outFilter = CORE_FILTER_LINEAR;
            outMipmapMode = CORE_FILTER_LINEAR;
            break;

        case GLTF2::FilterMode::NEAREST_MIPMAP_NEAREST:
            outFilter = CORE_FILTER_NEAREST;
            outMipmapMode = CORE_FILTER_NEAREST;
            break;

        case GLTF2::FilterMode::LINEAR_MIPMAP_NEAREST:
            outFilter = CORE_FILTER_LINEAR;
            outMipmapMode = CORE_FILTER_NEAREST;
            break;

        case GLTF2::FilterMode::NEAREST_MIPMAP_LINEAR:
            outFilter = CORE_FILTER_NEAREST;
            outMipmapMode = CORE_FILTER_LINEAR;
            break;

        case GLTF2::FilterMode::LINEAR_MIPMAP_LINEAR:
            outFilter = CORE_FILTER_LINEAR;
            outMipmapMode = CORE_FILTER_LINEAR;
            break;
    }
}

void ConvertToCoreFilter(GLTF2::FilterMode mode, Filter& outFilter)
{
    Filter unused;
    ConvertToCoreFilter(mode, outFilter, unused);
}

SamplerAddressMode ConvertToCoreWrapMode(GLTF2::WrapMode mode)
{
    switch (mode) {
        default:
        case GLTF2::WrapMode::CLAMP_TO_EDGE:
            return CORE_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;

        case GLTF2::WrapMode::MIRRORED_REPEAT:
            return CORE_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT;

        case GLTF2::WrapMode::REPEAT:
            return CORE_SAMPLER_ADDRESS_MODE_REPEAT;
    }
}

void RecursivelyCreateEntities(IEntityManager& entityManager, GLTF2::Data const& data, GLTF2::Node const& node,
    unordered_map<size_t, Entity>& sceneEntities)
{
    // Look up node index nodes array.
    if (size_t const nodeIndex = FindIndex(data.nodes, &node); nodeIndex != GLTF2::GLTF_INVALID_INDEX) {
        // Create entity for this node in this scene.
        sceneEntities[nodeIndex] = entityManager.Create();
    } else {
        // NOTE: Failed to find given node.
    }

    for (auto child : node.children) {
        RecursivelyCreateEntities(entityManager, data, *child, sceneEntities);
    }
}

Entity FindEntity(unordered_map<size_t, Entity> const& sceneEntities, size_t nodeIndex)
{
    if (auto const pos = sceneEntities.find(nodeIndex); pos != sceneEntities.end()) {
        return pos->second;
    } else {
        return {};
    }
}

void CreateNode(IEcs& ecs, const GLTF2::Node& node, const Entity entity, const GLTF2::Data& data,
    const unordered_map<size_t, Entity>& sceneEntities, const Entity sceneEntity, const uint32_t sceneId)
{
    INodeComponentManager& nodeManager = *(GetManager<INodeComponentManager>(ecs));
    nodeManager.Create(entity);

    ScopedHandle<NodeComponent> component = nodeManager.Write(entity);
    component->sceneId = sceneId;
    if (const size_t parentIndex = FindIndex(data.nodes, node.parent); parentIndex != GLTF2::GLTF_INVALID_INDEX) {
        component->parent = FindEntity(sceneEntities, parentIndex);
    } else {
        // Set as child of scene.
        component->parent = sceneEntity;
    }
}

void CreateName(IEcs& ecs, const GLTF2::Node& node, const Entity entity)
{
    INameComponentManager& nameManager = *(GetManager<INameComponentManager>(ecs));
    nameManager.Create(entity);
    ScopedHandle<NameComponent> nameHandle = nameManager.Write(entity);
    nameHandle->name = node.name;
}

void CreateTransform(IEcs& ecs, const GLTF2::Node& node, const Entity entity)
{
    ITransformComponentManager& transformManager = *(GetManager<ITransformComponentManager>(ecs));

    transformManager.Create(entity);

    GetManager<ILocalMatrixComponentManager>(ecs)->Create(entity);
    GetManager<IWorldMatrixComponentManager>(ecs)->Create(entity);

    ScopedHandle<TransformComponent> component = transformManager.Write(entity);
    if (node.usesTRS) {
        component->position = node.translation;
        component->rotation = node.rotation;
        component->scale = node.scale;
    } else {
        Math::Vec3 skew;
        Math::Vec4 perspective;

        if (!Math::Decompose(
                node.matrix, component->scale, component->rotation, component->position, skew, perspective)) {
            component->position = { 0.f, 0.f, 0.f };
            component->rotation = { 0.f, 0.f, 0.f, 1.f };
            component->scale = { 1.f, 1.f, 1.f };
        }
    }
}

void CreateMesh(IEcs& ecs, const GLTF2::Node& node, const Entity entity, const GLTF2::Data& data,
    const GLTFResourceData& gltfResourceData)
{
    const size_t meshIndex = FindIndex(data.meshes, node.mesh);
    if (meshIndex != GLTF2::GLTF_INVALID_INDEX && meshIndex < gltfResourceData.meshes.size()) {
        IRenderMeshComponentManager& renderMeshManager = *(GetManager<IRenderMeshComponentManager>(ecs));

        renderMeshManager.Create(entity);
        ScopedHandle<RenderMeshComponent> component = renderMeshManager.Write(entity);
        component->mesh = gltfResourceData.meshes[meshIndex];
    }
}

void CreateCamera(IEcs& ecs, const GLTF2::Node& node, const Entity entity, const Entity environmentEntity)
{
    if (node.camera && node.camera->type != GLTF2::CameraType::INVALID) {
        ICameraComponentManager& cameraManager = *(GetManager<ICameraComponentManager>(ecs));
        cameraManager.Create(entity);
        ScopedHandle<CameraComponent> component = cameraManager.Write(entity);
        if (node.camera->type == GLTF2::CameraType::ORTHOGRAPHIC) {
            component->projection = CameraComponent::Projection::ORTHOGRAPHIC;
            component->xMag = node.camera->attributes.ortho.xmag;
            component->yMag = node.camera->attributes.ortho.ymag;
            component->zFar = node.camera->attributes.ortho.zfar;
            component->zNear = node.camera->attributes.ortho.znear;
        } else {
            // GLTF2::CameraType::PERSPECTIVE
            component->projection = CameraComponent::Projection::PERSPECTIVE;
            component->aspect = node.camera->attributes.perspective.aspect;
            component->yFov = node.camera->attributes.perspective.yfov;
            component->zFar = node.camera->attributes.perspective.zfar;
            component->zNear = node.camera->attributes.perspective.znear;
        }
        component->environment = environmentEntity;
    }
}

#if defined(GLTF2_EXTENSION_KHR_LIGHTS) || defined(GLTF2_EXTENSION_KHR_LIGHTS_PBR)
void CreateLight(IEcs& ecs, const GLTF2::Node& node, const Entity entity)
{
    if (node.light && node.light->type != GLTF2::LightType::INVALID) {
        ILightComponentManager& lightManager = *(GetManager<ILightComponentManager>(ecs));

        LightComponent component = CreateComponent(lightManager, entity);

        component.type = ConvertToCoreLightType(node.light->type);
        component.intensity = node.light->intensity;
        component.color = { node.light->color.x, node.light->color.y, node.light->color.z };

        if (component.type == LightComponent::Type::POINT || component.type == LightComponent::Type::SPOT) {
            // Positional parameters.
            component.range = node.light->positional.range;

            if (component.type == LightComponent::Type::SPOT) {
                // Spot parameters.
                component.spotInnerAngle = node.light->positional.spot.innerAngle;
                component.spotOuterAngle = node.light->positional.spot.outerAngle;
            }
        }

        lightManager.Set(entity, component);
    }
}
#endif

void RecursivelyCreateComponents(IEcs& ecs, const GLTF2::Data& data, const GLTF2::Node& node,
    const unordered_map<size_t, Entity>& sceneEntities, const Entity sceneEntity, const uint32_t sceneId,
    const Entity environmentEntity, const GLTFResourceData& gltfResourceData, Entity& defaultCamera, uint32_t flags)
{
    const size_t nodeIndex = FindIndex(data.nodes, &node);
    CORE_ASSERT_MSG(nodeIndex != GLTF2::GLTF_INVALID_INDEX, "Cannot find node: %s", node.name.c_str());

    const Entity entity = FindEntity(sceneEntities, nodeIndex);

    // Apply to node hierarchy.
    CreateNode(ecs, node, entity, data, sceneEntities, sceneEntity, sceneId);

    // Add name.
    CreateName(ecs, node, entity);

    // Apply transform.
    CreateTransform(ecs, node, entity);

    // Apply mesh.
    if (node.mesh && (flags & CORE_GLTF_IMPORT_COMPONENT_MESH)) {
        CreateMesh(ecs, node, entity, data, gltfResourceData);
    }

    // Apply camera.
    if (flags & CORE_GLTF_IMPORT_COMPONENT_CAMERA) {
        CreateCamera(ecs, node, entity, environmentEntity);

        if (!EntityUtil::IsValid(defaultCamera)) {
            defaultCamera = entity;
        }
    }

#if defined(GLTF2_EXTENSION_KHR_LIGHTS) || defined(GLTF2_EXTENSION_KHR_LIGHTS_PBR)
    // Apply light.
    if (flags & CORE_GLTF_IMPORT_COMPONENT_LIGHT) {
        CreateLight(ecs, node, entity);
    }
#endif

#if defined(GLTF2_EXTRAS_RSDZ)
    if (!node.modelIdRSDZ.empty()) {
        IRSDZModelIdComponentManager& rsdzManager = *(GetManager<IRSDZModelIdComponentManager>(ecs));
        RSDZModelIdComponent component = CreateComponent(rsdzManager, entity);
        StringUtil::CopyStringToArray(
            node.modelIdRSDZ, component.modelId, StringUtil::MaxStringLengthFromArray(component.modelId));
        rsdzManager.Set(entity, component);
    }
#endif

    for (auto child : node.children) {
        RecursivelyCreateComponents(ecs, data, *child, sceneEntities, sceneEntity, sceneId, environmentEntity,
            gltfResourceData, defaultCamera, flags);
    }
}

void AddSkinJointsComponents(const GLTF2::Data& data, const GLTFResourceData& gltfResourceData, ISkinningSystem& ss,
    const unordered_map<size_t, Entity>& sceneEntities)
{
    auto skinEntityIt = gltfResourceData.skins.begin();
    auto skinJointsManager = GetManager<ISkinJointsComponentManager>(ss.GetECS());
    // gltfResourceData.skins and data.skins should be the same size but take min just in case.
    auto skins = array_view(data.skins.data(), Math::min(gltfResourceData.skins.size(), data.skins.size()));
    for (auto const& skin : skins) {
        if (skin && (*skinEntityIt)) {
            skinJointsManager->Create(*skinEntityIt);
            auto jointsHandle = skinJointsManager->Write(*skinEntityIt);
            jointsHandle->count = Math::min(countof(jointsHandle->jointEntities), skin->joints.size());
            auto jointEntities = array_view(jointsHandle->jointEntities, jointsHandle->count);
            std::transform(skin->joints.begin(), skin->joints.begin() + static_cast<ptrdiff_t>(jointsHandle->count),
                jointEntities.begin(), [&data, &sceneEntities](const auto& jointNode) {
                    size_t const jointNodeIndex = FindIndex(data.nodes, jointNode);
                    return FindEntity(sceneEntities, jointNodeIndex);
                });
        }
        ++skinEntityIt;
    }
}

void CreateSkinComponents(const GLTF2::Data& data, const GLTFResourceData& gltfResourceData, ISkinningSystem& ss,
    const unordered_map<size_t, Entity>& sceneEntities)
{
    auto skinJointsManager = GetManager<ISkinJointsComponentManager>(ss.GetECS());
    for (auto const& node : data.nodes) {
        if (!node->skin) {
            continue;
        }

        if (size_t const skinIndex = FindIndex(data.skins, node->skin);
            skinIndex != GLTF2::GLTF_INVALID_INDEX && skinIndex < gltfResourceData.skins.size()) {
            size_t const nodeIndex = FindIndex(data.nodes, node.get());
            Entity const entity = FindEntity(sceneEntities, nodeIndex);
            if (!EntityUtil::IsValid(entity)) {
                // node was not part of current scene
                continue;
            }

            Entity skeleton {};
            if (node->skin->skeleton) {
                size_t const skeletonIndex = FindIndex(data.nodes, node->skin->skeleton);
                skeleton = FindEntity(sceneEntities, skeletonIndex);
            }

            vector<Entity> joints;
            if (auto jointsHandle = skinJointsManager->Read(gltfResourceData.skins[skinIndex]); jointsHandle) {
                joints.append(jointsHandle->jointEntities, jointsHandle->jointEntities + jointsHandle->count);
            } else {
                joints.reserve(node->skin->joints.size());
                std::transform(node->skin->joints.begin(), node->skin->joints.end(), std::back_inserter(joints),
                    [&data, &sceneEntities](const auto& jointNode) {
                        size_t const jointNodeIndex = FindIndex(data.nodes, jointNode);
                        return FindEntity(sceneEntities, jointNodeIndex);
                    });
            }
            ss.CreateInstance(gltfResourceData.skins[skinIndex], joints, entity, skeleton);
        }
    }
}

void CreateMorphComponents(const GLTF2::Data& data, const GLTFResourceData& gltfResourceData,
    IMorphComponentManager& mm, const unordered_map<size_t, Entity>& sceneEntities, const Entity sceneEntity)
{
    for (auto const& node : data.nodes) {
        if (!node->mesh || node->mesh->primitives.empty() || node->mesh->primitives[0].targets.empty()) {
            continue;
        }
        const size_t meshIndex = FindIndex(data.meshes, node->mesh);
        if ((meshIndex == GLTF2::GLTF_INVALID_INDEX) || (meshIndex >= gltfResourceData.meshes.size())) {
            continue;
        }
        const size_t nodeIndex = FindIndex(data.nodes, node.get());
        const Entity entity = FindEntity(sceneEntities, nodeIndex);
        if (!EntityUtil::IsValid(entity)) {
            // node was not part of current scene
            continue;
        }
        const size_t weightCount = node->mesh->primitives[0].targets.size();
        // Assert that all primitives have the same targets. (the spec is a bit confusing here or i just
        // can't read.)
        for (const auto& primitive : node->mesh->primitives) {
            CORE_UNUSED(primitive);
            CORE_ASSERT(primitive.targets.size() == weightCount);
        }

        // We have targets, so prepare the morph system/component.
        vector<string> names;
        names.reserve(weightCount);
        std::transform(node->mesh->primitives[0].targets.cbegin(), node->mesh->primitives[0].targets.cend(),
            std::back_inserter(names), [](const GLTF2::MorphTarget& target) { return target.name; });

        // Apparently the node/mesh weight list is a concatenation of all primitives targets weights....
        vector<float> weights;
        weights.reserve(weightCount);
        if (!node->weights.empty()) {
            // Use instance weight (if there is one)
            weights.append(node->weights.cbegin(),
                node->weights.cbegin() + static_cast<decltype(node->weights)::difference_type>(weightCount));
        } else if (!node->mesh->weights.empty()) {
            // Use mesh weight (if there is one)
            weights.append(node->mesh->weights.cbegin(),
                node->mesh->weights.cbegin() + static_cast<decltype(node->weights)::difference_type>(weightCount));
        } else {
            // Default to zero weight.
            weights.append(weightCount, 0.f);
        }

        mm.Create(entity);
        auto handle = mm.Write(entity);
        handle->morphNames = BASE_NS::move(names);
        handle->morphWeights = BASE_NS::move(weights);
    }
}

EntityReference GetImageEntity(IEcs& ecs, const GLTFResourceData& gltfResourceData, size_t index)
{
    if ((index != CORE_GLTF_INVALID_INDEX) && (index < gltfResourceData.images.size()) &&
        GetManager<IRenderHandleComponentManager>(ecs)->HasComponent(gltfResourceData.images[index])) {
        return gltfResourceData.images[index];
    }
    return {};
}

Entity CreateEnvironmentComponent(IGpuResourceManager& gpuResourceManager, const GLTF2::Data& data,
    const GLTFResourceData& gltfResourceData, IEcs& ecs, Entity sceneEntity, const size_t lightIndex)
{
    Entity environmentEntity;
#if defined(GLTF2_EXTENSION_EXT_LIGHTS_IMAGE_BASED)
    if (lightIndex == GLTF2::GLTF_INVALID_INDEX || lightIndex >= data.imageBasedLights.size()) {
        return environmentEntity;
    }
    // Create the component to the sceneEntity for convinience.
    environmentEntity = sceneEntity;
    IEnvironmentComponentManager& envManager = *(GetManager<IEnvironmentComponentManager>(ecs));
    envManager.Create(environmentEntity);
    auto envHandle = envManager.Write(environmentEntity);

    GLTF2::ImageBasedLight* light = data.imageBasedLights[lightIndex].get();
    envHandle->indirectDiffuseFactor.w = light->intensity;
    envHandle->indirectSpecularFactor.w = light->intensity;
    envHandle->envMapFactor.w = light->intensity;

    envHandle->environmentRotation = light->rotation;

    // Either we have full set of coefficients or there are no coefficients at all.
    CORE_ASSERT(light->irradianceCoefficients.size() == 0u || light->irradianceCoefficients.size() == 9u);

    std::transform(light->irradianceCoefficients.begin(), light->irradianceCoefficients.end(),
        envHandle->irradianceCoefficients, [](const GLTF2::ImageBasedLight::LightingCoeff& coeff) {
            // Each coefficient needs to have three components.
            CORE_ASSERT(coeff.size() == 3u);

            // Values are expected to be prescaled with 1.0 / PI for Lambertian diffuse
            return Math::Vec3(coeff[0u], coeff[1u], coeff[2u]);
        });

    if (lightIndex < gltfResourceData.specularRadianceCubemaps.size() &&
        EntityUtil::IsValid(gltfResourceData.specularRadianceCubemaps[lightIndex])) {
        envHandle->radianceCubemap = gltfResourceData.specularRadianceCubemaps[lightIndex];
        envHandle->radianceCubemapMipCount = (uint32_t)light->specularImages.size();
    }

    if (auto imageEntity = GetImageEntity(ecs, gltfResourceData, light->specularCubeImage); imageEntity) {
        envHandle->radianceCubemap = imageEntity;
    }

    envHandle->envMapLodLevel = light->skymapImageLodLevel;

    if (auto imageEntity = GetImageEntity(ecs, gltfResourceData, light->skymapImage); imageEntity) {
        envHandle->envMap = imageEntity;
        IRenderHandleComponentManager& gpuHandleManager = *(GetManager<IRenderHandleComponentManager>(ecs));
        if (const auto& envMapHandle = gpuHandleManager.Read(imageEntity)->reference; envMapHandle) {
            const ImageViewType imageViewType = gpuResourceManager.GetImageDescriptor(envMapHandle).imageViewType;
            envHandle->background = (imageViewType == CORE_IMAGE_VIEW_TYPE_CUBE)
                                        ? EnvironmentComponent::Background::CUBEMAP
                                        : EnvironmentComponent::Background::EQUIRECTANGULAR;
        }
    }

#endif
    return environmentEntity;
}

GLTF2::ImportPhase operator+(GLTF2::ImportPhase lhs, int rhs)
{
    return static_cast<GLTF2::ImportPhase>(static_cast<int>(lhs) + rhs);
}

using ImageLoadResultVector = vector<IImageLoaderManager::LoadResult>;

struct ImageData {
    vector<uint8_t> data;
    vector<BufferImageCopy> copyInfo;
};

ImageData PrepareImageData(const ImageLoadResultVector& imageLoadResults, const GpuImageDesc& imageDesc)
{
    ImageData data;
    const size_t availableMipLayerCount = imageLoadResults.size() / imageDesc.layerCount;
    data.copyInfo.resize(availableMipLayerCount);

    // For all mip levels.
    size_t byteOffset = 0;
    for (size_t mipIndex = 0; mipIndex < availableMipLayerCount; ++mipIndex) {
        {
            const auto& imageLoadResult = imageLoadResults[(mipIndex * 6u)];
            if (!imageLoadResult.image) {
                continue;
            }
            const auto& loadedImageDesc = imageLoadResult.image->GetImageDesc();
            const auto& loadedBufferImageCopy = imageLoadResult.image->GetBufferImageCopies()[0];

            BufferImageCopy& bufferCopy = data.copyInfo[mipIndex];
            bufferCopy.bufferOffset = (uint32_t)byteOffset;
            bufferCopy.bufferRowLength = loadedBufferImageCopy.bufferRowLength;
            bufferCopy.bufferImageHeight = loadedBufferImageCopy.bufferImageHeight;
            bufferCopy.imageOffset.width = 0;
            bufferCopy.imageOffset.height = 0;
            bufferCopy.imageOffset.depth = 0;
            bufferCopy.imageExtent.width = loadedImageDesc.width;
            bufferCopy.imageExtent.height = loadedImageDesc.height;
            bufferCopy.imageExtent.depth = loadedImageDesc.depth;
            bufferCopy.imageSubresource.imageAspectFlags = CORE_IMAGE_ASPECT_COLOR_BIT;
            bufferCopy.imageSubresource.mipLevel = (uint32_t)mipIndex;
            bufferCopy.imageSubresource.baseArrayLayer = 0;
            bufferCopy.imageSubresource.layerCount = imageDesc.layerCount;
        }

        for (uint32_t face = 0; face < imageDesc.layerCount; ++face) {
            const auto& cubeFaceLoadResult = imageLoadResults[(mipIndex * imageDesc.layerCount) + face];
            const auto& cubeFaceBufferImageCopy = cubeFaceLoadResult.image->GetBufferImageCopies()[0];

            const auto& loadedImageData = cubeFaceLoadResult.image->GetData();
            data.data.append(loadedImageData.begin() + cubeFaceBufferImageCopy.bufferOffset, loadedImageData.end());

            byteOffset += loadedImageData.size() - cubeFaceBufferImageCopy.bufferOffset;
        }
    }
    return data;
}

RenderHandleReference CreateCubemapFromImages(
    uint32_t imageSize, const ImageLoadResultVector& imageLoadResults, IGpuResourceManager& gpuResourceManager)
{
    if (!imageLoadResults[0].image) {
        return {};
    }

    // Calculate number of mipmaps needed.
    uint32_t mipsize = imageSize;
    uint32_t totalMipCount = 0;
    while (mipsize > 0) {
        ++totalMipCount;
        mipsize >>= 1;
    }

    const ImageUsageFlags usageFlags =
        CORE_IMAGE_USAGE_SAMPLED_BIT | CORE_IMAGE_USAGE_TRANSFER_DST_BIT | CORE_IMAGE_USAGE_TRANSFER_SRC_BIT;

    const GpuImageDesc imageDesc = {
        ImageType::CORE_IMAGE_TYPE_2D,                                 // imageType
        CORE_IMAGE_VIEW_TYPE_CUBE,                                     // imageViewType
        imageLoadResults[0].image->GetImageDesc().format,              // format
        ImageTiling::CORE_IMAGE_TILING_OPTIMAL,                        // imageTiling
        usageFlags,                                                    // usageFlags
        MemoryPropertyFlagBits::CORE_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, // memoryPropertyFlags
        ImageCreateFlagBits::CORE_IMAGE_CREATE_CUBE_COMPATIBLE_BIT,    // createFlags
        CORE_ENGINE_IMAGE_CREATION_GENERATE_MIPS,                      // engineCreationFlags
        imageSize,                                                     // width
        imageSize,                                                     // height
        1,                                                             // depth
        totalMipCount,                                                 // mipCount
        6,                                                             // layerCount
        SampleCountFlagBits::CORE_SAMPLE_COUNT_1_BIT,                  // sampleCountFlags
        {},                                                            // componentMapping
    };

    const auto data = PrepareImageData(imageLoadResults, imageDesc);

    auto handle = gpuResourceManager.Create("", imageDesc, data.data, data.copyInfo);
    if (!handle) {
        CORE_LOG_W("Creating an import cubemap image failed (format:%u, width:%u, height:%u)",
            static_cast<uint32_t>(imageDesc.format), imageDesc.width, imageDesc.height);
    }
    return handle;
}

auto FillShaderData(IEntityManager& em, IUriComponentManager& uriManager,
    IRenderHandleComponentManager& renderHandleMgr, const string_view renderSlot,
    GLTF2::GLTF2Importer::DefaultMaterialShaderData::SingleShaderData& shaderData)
{
    auto uri = "3dshaders://" + renderSlot;
    auto resourceEntity = LookupResourceByUri(uri, uriManager, renderHandleMgr);
    shaderData.shader = em.GetReferenceCounted(resourceEntity);

    uri = "3dshaderstates://";
    uri += renderSlot;
    resourceEntity = LookupResourceByUri(uri, uriManager, renderHandleMgr);
    shaderData.gfxState = em.GetReferenceCounted(resourceEntity);

    uri += "_DBL";
    resourceEntity = LookupResourceByUri(uri, uriManager, renderHandleMgr);
    shaderData.gfxStateDoubleSided = em.GetReferenceCounted(resourceEntity);
    if (!(EntityUtil::IsValid(shaderData.shader) && EntityUtil::IsValid(shaderData.gfxState) &&
            EntityUtil::IsValid(shaderData.gfxStateDoubleSided))) {
        CORE_LOG_ONCE_W(renderSlot, "GLTF2 importer cannot find default shader data.");
    }
}
} // namespace

Entity ImportScene(IDevice& device, size_t sceneIndex, const GLTF2::Data& data,
    const GLTFResourceData& gltfResourceData, IEcs& ecs, Entity rootEntity, uint32_t sceneId,
    GltfSceneImportFlags flags)
{
    if (sceneIndex >= data.scenes.size()) {
        return {};
    }
    // Create entity for this scene.
    const Entity sceneEntity = ecs.GetEntityManager().Create();

    // Create default components for scene.
    ITransformComponentManager& transformManager = *(GetManager<ITransformComponentManager>(ecs));
    transformManager.Create(sceneEntity);
    ILocalMatrixComponentManager& localMatrixManager = *(GetManager<ILocalMatrixComponentManager>(ecs));
    localMatrixManager.Create(sceneEntity);
    IWorldMatrixComponentManager& worldMatrixManager = *(GetManager<IWorldMatrixComponentManager>(ecs));
    worldMatrixManager.Create(sceneEntity);

    auto& scene = data.scenes[sceneIndex];

    INodeComponentManager& nodeManager = *(GetManager<INodeComponentManager>(ecs));
    nodeManager.Create(sceneEntity);

    // IGltf2::ImportGltfScene has two overloads: either rootEntity or sceneId is given. If rootEntity is valid use the
    // sceneId from that node.
    if (EntityUtil::IsValid(rootEntity)) {
        if (auto nodeHandle = nodeManager.Read(rootEntity)) {
            sceneId = nodeHandle->sceneId;
        }
    }

    if (auto nodeHandle = nodeManager.Write(sceneEntity)) {
        nodeHandle->parent = rootEntity;
        nodeHandle->sceneId = sceneId;
    }

    // Add name.
    {
        INameComponentManager& nameManager = *(GetManager<INameComponentManager>(ecs));
        nameManager.Create(sceneEntity);
        ScopedHandle<NameComponent> nameHandle = nameManager.Write(sceneEntity);
        nameHandle->name = scene->name;
    }

    // Default camera.
    Entity defaultCamera;

    IEntityManager& em = ecs.GetEntityManager();

    // Create environment.
    Entity environment;
    if (flags & CORE_GLTF_IMPORT_COMPONENT_ENVIRONMENT) {
#if defined(GLTF2_EXTENSION_EXT_LIGHTS_IMAGE_BASED)
        const size_t lightIndex = scene->imageBasedLightIndex;
#else
        const size_t lightIndex = 0; // Not used.
#endif
        environment = CreateEnvironmentComponent(
            device.GetGpuResourceManager(), data, gltfResourceData, ecs, sceneEntity, lightIndex);
    }

    // Create entities for nodes in scene.
    unordered_map<size_t, Entity> sceneEntities;
    for (auto node : scene->nodes) {
        RecursivelyCreateEntities(em, data, *node, sceneEntities);
    }

    // Create components for all nodes in this scene.
    for (auto node : scene->nodes) {
        RecursivelyCreateComponents(
            ecs, data, *node, sceneEntities, sceneEntity, sceneId, environment, gltfResourceData, defaultCamera, flags);
    }

    // Apply skins only after the node hiearachy is complete.
    if (flags & CORE_GLTF_IMPORT_COMPONENT_SKIN) {
        if (ISkinningSystem* ss = GetSystem<ISkinningSystem>(ecs); ss) {
            AddSkinJointsComponents(data, gltfResourceData, *ss, sceneEntities);
            CreateSkinComponents(data, gltfResourceData, *ss, sceneEntities);
        }
    }

    // Add the morphing system to entity if needed. (contains the target weights)
    if (flags & CORE_GLTF_IMPORT_COMPONENT_MORPH) {
        if (IMorphComponentManager* mm = GetManager<IMorphComponentManager>(ecs); mm) {
            CreateMorphComponents(data, gltfResourceData, *mm, sceneEntities, sceneEntity);
        }
    }

    return sceneEntity;
}

namespace GLTF2 {
struct GLTF2Importer::ImporterTask {
    virtual ~ImporterTask() = default;

    enum class State { Queued, Gather, Import, Finished };

    string name;
    string errors;
    uint64_t id;
    bool success { true };

    std::function<bool()> gather;
    std::function<bool()> import;
    std::function<void()> finished;

    State state { State::Queued };
    ImportPhase phase { ImportPhase::FINISHED };
};

class GLTF2Importer::GatherThreadTask final : public IThreadPool::ITask {
public:
    explicit GatherThreadTask(GLTF2Importer& importer, ImporterTask& task) : importer_(importer), task_(task) {};

    void operator()() override
    {
        importer_.Gather(task_);
    }

protected:
    void Destroy() override
    {
        delete this;
    }

private:
    GLTF2Importer& importer_;
    ImporterTask& task_;
};

class GLTF2Importer::ImportThreadTask final : public IThreadPool::ITask {
public:
    explicit ImportThreadTask(GLTF2Importer& importer, ImporterTask& task) : importer_(importer), task_(task) {};

    void operator()() override
    {
        importer_.Import(task_);
    }

protected:
    void Destroy() override
    {
        delete this;
    }

private:
    GLTF2Importer& importer_;
    ImporterTask& task_;
};

template<class T>
struct GLTF2Importer::GatheredDataTask : GLTF2Importer::ImporterTask {
    T data;
};

template<typename Component>
struct GLTF2Importer::ComponentTaskData {
    EntityReference entity;
    Component component;
};

struct GLTF2Importer::AnimationTaskData {
    GLTF2Importer* importer;
    size_t index;
    string uri;
    string_view name;
    IAnimationComponentManager* animationManager;
    IAnimationTrackComponentManager* trackManager;
    vector<GatheredDataTask<ComponentTaskData<AnimationInputComponent>>*> inputs;
    vector<GatheredDataTask<ComponentTaskData<AnimationOutputComponent>>*> outputs;

    bool operator()()
    {
        const auto& tracks = importer->data_->animations[index]->tracks;
        if (inputs.size() < tracks.size() || outputs.size() < tracks.size()) {
            return false;
        }
        auto& entityManager = importer->ecs_->GetEntityManager();

        auto animationEntity = entityManager.CreateReferenceCounted();
        animationManager->Create(animationEntity);
        const auto animationHandle = animationManager->Write(animationEntity);

        auto& animationTracks = animationHandle->tracks;
        animationTracks.reserve(tracks.size());
        auto inputIt = inputs.begin();
        auto outputIt = outputs.begin();
        float maxLength = 0.f;
        for (const auto& track : tracks) {
            if (track.sampler) {
                const auto animationTrackEntity = entityManager.CreateReferenceCounted();
                animationTracks.push_back(animationTrackEntity);

                trackManager->Create(animationTrackEntity);
                if (auto trackHandle = trackManager->Write(animationTrackEntity); trackHandle) {
                    if (track.channel.node) {
                        // Name the track with the path to the target node. Scene import can then find the
                        // target entity.
                        importer->nameManager_->Create(animationTrackEntity);
                        importer->nameManager_->Write(animationTrackEntity)->name =
                            ResolveNodePath(*track.channel.node);
                    }

                    SelectComponentProperty(track.channel.path, *trackHandle);

                    trackHandle->interpolationMode = ConvertAnimationInterpolation(track.sampler->interpolation);
                    trackHandle->timestamps = (*inputIt)->data.entity;
                    trackHandle->data = (*outputIt)->data.entity;
                    if (!(*inputIt)->data.component.timestamps.empty()) {
                        maxLength = Math::max(maxLength, (*inputIt)->data.component.timestamps.back());
                    }
                }
                ++inputIt;
                ++outputIt;
            }
        }
        animationHandle->duration = maxLength;
        if (!uri.empty()) {
            importer->uriManager_->Create(animationEntity);
            importer->uriManager_->Write(animationEntity)->uri = move(uri);
        }
        if (!name.empty()) {
            importer->nameManager_->Create(animationEntity);
            importer->nameManager_->Write(animationEntity)->name = name;
        }
        importer->result_.data.animations[index] = move(animationEntity);
        return true;
    }

    static void SelectComponentProperty(AnimationPath pathType, AnimationTrackComponent& trackComponent)
    {
        switch (pathType) {
            case GLTF2::AnimationPath::INVALID:
                CORE_ASSERT(false);
                break;
            case GLTF2::AnimationPath::TRANSLATION:
                trackComponent.component = ITransformComponentManager::UID;
                trackComponent.property = "position";
                break;
            case GLTF2::AnimationPath::ROTATION:
                trackComponent.component = ITransformComponentManager::UID;
                trackComponent.property = "rotation";
                break;
            case GLTF2::AnimationPath::SCALE:
                trackComponent.component = ITransformComponentManager::UID;
                trackComponent.property = "scale";
                break;
            case GLTF2::AnimationPath::WEIGHTS:
                trackComponent.component = IMorphComponentManager::UID;
                trackComponent.property = "morphWeights";
                break;
            case GLTF2::AnimationPath::VISIBLE:
                trackComponent.component = INodeComponentManager::UID;
                trackComponent.property = "enabled";
                break;
            case GLTF2::AnimationPath::OPACITY:
                trackComponent.component = IMaterialComponentManager::UID;
                trackComponent.property = "enabled";
                break;
        }
    }
};

GLTF2Importer::GLTF2Importer(IEngine& engine, IRenderContext& renderContext, IEcs& ecs, IThreadPool& pool)
    : engine_(engine), renderContext_(renderContext), device_(renderContext.GetDevice()),
      gpuResourceManager_(device_.GetGpuResourceManager()), ecs_(&ecs),
      renderHandleManager_(GetManager<IRenderHandleComponentManager>(*ecs_)),
      materialManager_(GetManager<IMaterialComponentManager>(*ecs_)),
      meshManager_(GetManager<IMeshComponentManager>(*ecs_)), nameManager_(GetManager<INameComponentManager>(*ecs_)),
      uriManager_(GetManager<IUriComponentManager>(*ecs_)), threadPool_(&pool)
{
    if (IGraphicsContext* graphicsContext_ =
            GetInstance<IGraphicsContext>(*(renderContext_.GetInterface<IClassRegister>()), UID_GRAPHICS_CONTEXT);
        graphicsContext_) {
        colorSpaceFlags_ = graphicsContext_->GetCreateInfo().colorSpaceFlags;
    }

    const auto factory = GetInstance<ITaskQueueFactory>(UID_TASK_QUEUE_FACTORY);
    mainThreadQueue_ = factory->CreateDispatcherTaskQueue({});
    if (renderHandleManager_ && uriManager_) {
        // fetch default shaders and graphics states
        auto& entityMgr = ecs_->GetEntityManager();
        FillShaderData(entityMgr, *uriManager_, *renderHandleManager_,
            DefaultMaterialShaderConstants::RENDER_SLOT_FORWARD_OPAQUE, dmShaderData_.opaque);
        FillShaderData(entityMgr, *uriManager_, *renderHandleManager_,
            DefaultMaterialShaderConstants::RENDER_SLOT_FORWARD_TRANSLUCENT, dmShaderData_.blend);
        FillShaderData(entityMgr, *uriManager_, *renderHandleManager_,
            DefaultMaterialShaderConstants::RENDER_SLOT_DEPTH, dmShaderData_.depth);
    }
}

GLTF2Importer::GLTF2Importer(IEngine& engine, IRenderContext& renderContext, IEcs& ecs)
    : GLTF2Importer(engine, renderContext, ecs,
          *GetInstance<ITaskQueueFactory>(UID_TASK_QUEUE_FACTORY)->CreateThreadPool(IMPORTER_THREADS))
{}

GLTF2Importer::~GLTF2Importer()
{
    Cancel();
}

void GLTF2Importer::ImportGLTF(const IGLTFData& data, GltfResourceImportFlags flags)
{
    Cancel();
    cancelled_ = false;

    if (!renderHandleManager_ || !materialManager_ || !meshManager_ || !nameManager_ || !uriManager_) {
        result_.success = false;
        result_.error += "Missing required component managers.";
        return;
    }
    data_ = (const GLTF2::Data*)&data;
    if (!data_) {
        result_.success = false;
        result_.error += "Invalid IGLTFData to ImportGLTF.";
        return;
    }

    flags_ = flags;
    for (auto& pendingGatherTasks : pendingGatherTasks_) {
        pendingGatherTasks = 0U;
    }
    for (auto& finishedGatherTasks : finishedGatherTasks_) {
        finishedGatherTasks.clear();
    }
    result_.data.samplers.clear();
    result_.data.images.clear();
    result_.data.textures.clear();
    result_.data.materials.clear();
    result_.data.meshes.clear();
    result_.data.skins.clear();
    result_.data.animations.clear();
    result_.data.specularRadianceCubemaps.clear();

    meshBuilders_.clear();

    // Build tasks.
    Prepare();

    // Fill in task queues for first tasks.
    StartPhase(ImportPhase::BUFFERS);

    // Run until completed.
    while (!Execute(0)) {
        if (gatherResults_[static_cast<uint32_t>(phase_)]) {
            gatherResults_[static_cast<uint32_t>(phase_)]->Wait();
        }
    }
}

void GLTF2Importer::ImportGLTFAsync(const IGLTFData& data, GltfResourceImportFlags flags, Listener* listener)
{
    Cancel();
    cancelled_ = false;

    if (!renderHandleManager_ || !materialManager_ || !meshManager_ || !nameManager_ || !uriManager_) {
        result_.success = false;
        result_.error += "Missing required component managers.";
        return;
    }

    data_ = (const GLTF2::Data*)&data;
    if (!data_) {
        result_.success = false;
        result_.error += "Invalid IGLTFData to ImportGLTFAsync.";
        return;
    }

    flags_ = flags;

    result_.success = true;
    result_.error.clear();
    result_.data.samplers.clear();
    result_.data.images.clear();
    result_.data.textures.clear();
    result_.data.materials.clear();
    result_.data.meshes.clear();
    result_.data.skins.clear();
    result_.data.animations.clear();
    result_.data.specularRadianceCubemaps.clear();

    meshBuilders_.clear();

    listener_ = listener;

    // Build tasks.
    Prepare();

    // Fill in task queues for first tasks.
    StartPhase(ImportPhase::BUFFERS);
}

void GLTF2Importer::Cancel()
{
    if (!IsCompleted()) {
        cancelled_ = true;
        // Wait all ongoing threads to complete.
        for (auto& result : gatherResults_) {
            if (result) {
                result->Wait();
            }
        }

        StartPhase(ImportPhase::FINISHED);
    }
}

bool GLTF2Importer::IsCompleted() const
{
    return phase_ == ImportPhase::FINISHED;
}

const GLTFImportResult& GLTF2Importer::GetResult() const
{
    return result_;
}

const GltfMeshData& GLTF2Importer::GetMeshData() const
{
    return meshData_;
}

bool GLTF2Importer::IsValid() const
{
    return uriManager_ && renderHandleManager_ && materialManager_ && meshManager_ && nameManager_ && uriManager_;
}

void GLTF2Importer::LaunchGatherTasks(size_t firstTask, ImportPhase phase)
{
    auto first = tasks_.begin() + static_cast<ptrdiff_t>(firstTask);
    const auto end = tasks_.end();
    const auto taskCount = static_cast<size_t>(std::distance(first, end));
    vector<const IThreadPool::ITask*> tasks;
    tasks.reserve(taskCount);
    while (first != end) {
        auto& task = **first;
        if (task.phase == phase) {
            task.state = ImporterTask::State::Gather;
            auto threadTask = IThreadPool::ITask::Ptr { new GatherThreadTask(*this, task) };
            tasks.push_back(threadTask.get());
            threadPool_->PushNoWait(BASE_NS::move(threadTask), BASE_NS::array_view(&bufferTask_, 1U));
        }
        ++first;
    }
    // Add a task which waits for all the gather tasks for this cateory.
    if (!tasks.empty()) {
        gatherResults_[static_cast<uint32_t>(phase)] =
            threadPool_->Push(IThreadPool::ITask::Ptr { CreateFunctionTask([]() {}) }, tasks);
    }
}

void GLTF2Importer::Prepare()
{
    // Build tasks.
    PrepareBufferTasks();

    if (flags_ & CORE_GLTF_IMPORT_RESOURCE_SAMPLER) {
        PrepareSamplerTasks();
    }

    if (flags_ & CORE_GLTF_IMPORT_RESOURCE_IMAGE) {
        const auto firstTask = tasks_.size();
        PrepareImageTasks();
        PrepareImageBasedLightTasks();
        LaunchGatherTasks(firstTask, ImportPhase::IMAGES);
    }

    if (flags_ & CORE_GLTF_IMPORT_RESOURCE_MATERIAL) {
        PrepareMaterialTasks();
    }

    if (flags_ & CORE_GLTF_IMPORT_RESOURCE_ANIMATION) {
        const auto firstTask = tasks_.size();
        PrepareAnimationTasks();
        LaunchGatherTasks(firstTask, ImportPhase::ANIMATION_SAMPLERS);
    }

    if (flags_ & CORE_GLTF_IMPORT_RESOURCE_SKIN) {
        const auto firstTask = tasks_.size();
        PrepareSkinTasks();
        LaunchGatherTasks(firstTask, ImportPhase::SKINS);
    }

    if (flags_ & CORE_GLTF_IMPORT_RESOURCE_MESH) {
        const auto firstTask = tasks_.size();
        PrepareMeshTasks();
        LaunchGatherTasks(firstTask, ImportPhase::MESHES);
    }

    if (listener_) {
        listener_->OnImportStarted();
    }
}

void GLTF2Importer::QueueTask(unique_ptr<ImporterTask>&& task)
{
    size_t const taskIndex = tasks_.size();
    task->id = taskIndex;
    tasks_.push_back(move(task));
}

bool GLTF2Importer::ProgressTask(ImporterTask& task)
{
    if (task.state == ImporterTask::State::Queued) {
        // Task not started, proceed to gather phase.
        task.state = ImporterTask::State::Gather;
        if (task.gather) {
            // All gather task should be launched during Prepare() to fully utilize the thread pool.
            CORE_ASSERT(false);
            return false;
        }
    }

    if (task.state == ImporterTask::State::Gather) {
        // Gather phase started or skipped, proceed to import.
        task.state = ImporterTask::State::Import;
        if (task.import) {
            pendingImportTasks_++;
            mainThreadQueue_->Submit(task.id, IThreadPool::ITask::Ptr { new ImportThreadTask(*this, task) });
            return false;
        }
    }

    if (task.state == ImporterTask::State::Import) {
        CompleteTask(task);
    }

    return task.state == ImporterTask::State::Finished;
}

void GLTF2Importer::Gather(ImporterTask& task)
{
    {
        CORE_CPU_PERF_SCOPE("CORE3D", "Gather", task.name, CORE3D_PROFILER_DEFAULT_COLOR);

        if (cancelled_ || !task.gather()) {
            task.success = false;
        }
    }

    {
        // Mark task completed.
        std::lock_guard lock(gatherTasksLock_);
        finishedGatherTasks_[static_cast<uint32_t>(task.phase)].push_back(task.id);
    }
}

void GLTF2Importer::Import(ImporterTask& task)
{
    CORE_CPU_PERF_SCOPE("CORE3D", "Import", task.name, CORE3D_PROFILER_DEFAULT_COLOR);

    if (cancelled_ || !task.import()) {
        task.success = false;
    }
}

void GLTF2Importer::CompleteTask(ImporterTask& task)
{
    if (task.finished) {
        task.finished();
    }

    task.state = ImporterTask::State::Finished;

    completedTasks_++;

    if (listener_) {
        listener_->OnImportProgressed(completedTasks_, tasks_.size());
    }
}

void GLTF2Importer::StartPhase(ImportPhase phase)
{
    phase_ = phase;
    pendingImportTasks_ = 0;
    completedTasks_ = 0;

    if (phase == ImportPhase::FINISHED) {
        if ((flags_ & CORE_GLTF_IMPORT_RESOURCE_MESH_CPU_ACCESS) && !meshBuilders_.empty()) {
            {
                auto& shaderManager = renderContext_.GetDevice().GetShaderManager();
                const VertexInputDeclarationView vertexInputDeclaration =
                    shaderManager.GetVertexInputDeclarationView(shaderManager.GetVertexInputDeclarationHandle(
                        DefaultMaterialShaderConstants::VERTEX_INPUT_DECLARATION_FORWARD));
                meshData_.vertexInputDeclaration.bindingDescriptionCount =
                    static_cast<uint32_t>(vertexInputDeclaration.bindingDescriptions.size());
                meshData_.vertexInputDeclaration.attributeDescriptionCount =
                    static_cast<uint32_t>(vertexInputDeclaration.attributeDescriptions.size());
                std::copy(vertexInputDeclaration.bindingDescriptions.cbegin(),
                    vertexInputDeclaration.bindingDescriptions.cend(),
                    meshData_.vertexInputDeclaration.bindingDescriptions);
                std::copy(vertexInputDeclaration.attributeDescriptions.cbegin(),
                    vertexInputDeclaration.attributeDescriptions.cend(),
                    meshData_.vertexInputDeclaration.attributeDescriptions);
            }
            meshData_.meshes.resize(meshBuilders_.size());
            for (uint32_t mesh = 0U; mesh < meshBuilders_.size(); ++mesh) {
                if (!meshBuilders_[mesh]) {
                    continue;
                }
                auto& currentMesh = meshData_.meshes[mesh];
                auto vertexData = meshBuilders_[mesh]->GetVertexData();
                auto indexData = meshBuilders_[mesh]->GetIndexData();
                auto jointData = meshBuilders_[mesh]->GetJointData();
                auto submeshes = meshBuilders_[mesh]->GetSubmeshes();
                currentMesh.subMeshes.resize(submeshes.size());
                for (uint32_t subMesh = 0U; subMesh < submeshes.size(); ++subMesh) {
                    auto& currentSubMesh = currentMesh.subMeshes[subMesh];
                    currentSubMesh.indices = submeshes[subMesh].indexCount;
                    currentSubMesh.vertices = submeshes[subMesh].vertexCount;

                    currentSubMesh.indexBuffer = array_view(indexData.data() + submeshes[subMesh].indexBuffer.offset,
                        submeshes[subMesh].indexBuffer.byteSize);

                    auto& bufferAccess = submeshes[subMesh].bufferAccess;
                    auto fill = [](array_view<const uint8_t> data, const MeshComponent::Submesh::BufferAccess& buffer) {
                        if (buffer.offset > data.size() || buffer.offset + buffer.byteSize > data.size()) {
                            return array_view<const uint8_t> {};
                        }
                        return array_view(data.data() + buffer.offset, buffer.byteSize);
                    };
                    currentSubMesh.attributeBuffers[MeshComponent::Submesh::DM_VB_POS] =
                        fill(vertexData, bufferAccess[MeshComponent::Submesh::DM_VB_POS]);
                    currentSubMesh.attributeBuffers[MeshComponent::Submesh::DM_VB_NOR] =
                        fill(vertexData, bufferAccess[MeshComponent::Submesh::DM_VB_NOR]);
                    currentSubMesh.attributeBuffers[MeshComponent::Submesh::DM_VB_UV0] =
                        fill(vertexData, bufferAccess[MeshComponent::Submesh::DM_VB_UV0]);
                    if (submeshes[subMesh].flags & MeshComponent::Submesh::SECOND_TEXCOORD_BIT) {
                        currentSubMesh.attributeBuffers[MeshComponent::Submesh::DM_VB_UV1] =
                            fill(vertexData, bufferAccess[MeshComponent::Submesh::DM_VB_UV1]);
                    }
                    if (submeshes[subMesh].flags & MeshComponent::Submesh::TANGENTS_BIT) {
                        currentSubMesh.attributeBuffers[MeshComponent::Submesh::DM_VB_TAN] =
                            fill(vertexData, bufferAccess[MeshComponent::Submesh::DM_VB_TAN]);
                    }
                    if (submeshes[subMesh].flags & MeshComponent::Submesh::VERTEX_COLORS_BIT) {
                        currentSubMesh.attributeBuffers[MeshComponent::Submesh::DM_VB_COL] =
                            fill(vertexData, bufferAccess[MeshComponent::Submesh::DM_VB_COL]);
                    }
                    if (submeshes[subMesh].flags & MeshComponent::Submesh::SKIN_BIT) {
                        currentSubMesh.attributeBuffers[MeshComponent::Submesh::DM_VB_JOI] =
                            fill(jointData, bufferAccess[MeshComponent::Submesh::DM_VB_JOI]);
                        currentSubMesh.attributeBuffers[MeshComponent::Submesh::DM_VB_JOW] =
                            fill(jointData, bufferAccess[MeshComponent::Submesh::DM_VB_JOW]);
                    }
                }
            }
        }
        // All tasks are done.
        if (listener_) {
            listener_->OnImportFinished();
        }
        tasks_.clear();
        return;
    }

    for (auto& task : tasks_) {
        if (task->state == ImporterTask::State::Finished) {
            continue;
        }

        if (task->phase != phase) {
            continue;
        }

        // This will turn queued tasks to running ones.
        if (task->state == ImporterTask::State::Queued) {
            ProgressTask(*task);
        }
    }
}

GLTF2Importer::ImporterTask* GLTF2Importer::FindTaskById(uint64_t id)
{
    for (size_t i = 0; i < tasks_.size(); ++i) {
        if (tasks_[i]->id == id) {
            return tasks_[i].get();
        }
    }

    return nullptr;
}

bool GLTF2Importer::Execute(uint32_t timeBudget)
{
    if (IsCompleted()) {
        return true;
    }

    // Handle data gathering.
    HandleGatherTasks();

    // 'timeBudget' is given in microseconds
    const auto budget = std::chrono::microseconds(timeBudget);

    // Use steady_clock for measuring
    using Clock = std::chrono::steady_clock;

    // Start time.
    const auto s0 = Clock::now();

    // Handle resource / scene importing.
    while (pendingImportTasks_ > 0) {
        // Execute and handle one task.
        mainThreadQueue_->Execute();
        HandleImportTasks();

        // Check how much time has elapsed.
        if (timeBudget > 0) {
            const auto s1 = Clock::now();
            if (((s1 - s0) >= budget)) {
                // Break if whole time budget consumed.
                break;
            }
        }
    }

    // All tasks done for this phase?
    if ((!gatherResults_[static_cast<uint32_t>(phase_)] || gatherResults_[static_cast<uint32_t>(phase_)]->IsDone()) &&
        pendingImportTasks_ == 0) {
        // Proceed to next phase.
        StartPhase((ImportPhase)(phase_ + 1));
    }

    return IsCompleted();
}

void GLTF2Importer::HandleImportTasks()
{
    const vector<uint64_t> finishedImportTasks = mainThreadQueue_->CollectFinishedTasks();
    if (!finishedImportTasks.empty()) {
        pendingImportTasks_ -= finishedImportTasks.size();

        for (auto& finishedId : finishedImportTasks) {
            ImporterTask* task = FindTaskById(finishedId);
            if (task) {
                if (task->success) {
                    ProgressTask(*task);
                } else {
                    // Import phase failed.
                    const string error = "Import data failed: " + task->name;
                    CORE_LOG_W("%s", error.c_str());
                    result_.success = false;
                    result_.error += error + '\n';
                }
            }
        }
    }
}

void GLTF2Importer::HandleGatherTasks()
{
    auto& result = gatherResults_[static_cast<uint32_t>(phase_)];
    if (!result || !result->IsDone()) {
        return;
    }

    vector<uint64_t> finishedGatherTasks;
    {
        std::lock_guard lock(gatherTasksLock_);
        std::swap(finishedGatherTasks, finishedGatherTasks_[static_cast<uint32_t>(phase_)]);
    }

    if (finishedGatherTasks.size() > 0) {
        for (auto& finishedId : finishedGatherTasks) {
            ImporterTask* task = FindTaskById(finishedId);
            if (task) {
                if (task->success) {
                    ProgressTask(*task);
                } else {
                    // Gather phase failed.
                    const string error = "Gather data failed: " + task->name;
                    CORE_LOG_W("%s", error.c_str());
                    result_.success = false;
                    result_.error += error + '\n';
                }
                result_.error += task->errors;
            }
        }
    }
}

void GLTF2Importer::PrepareBufferTasks()
{
    // Buffers task.
    const auto firstTask = static_cast<ptrdiff_t>(tasks_.size());
    auto task = make_unique<ImporterTask>();
    task->name = "Load buffers";
    task->phase = ImportPhase::BUFFERS;
    task->gather = [this, t = task.get()]() -> bool {
        BufferLoadResult result = LoadBuffers(data_, engine_.GetFileManager());
        t->errors += result.error;
        return result.success;
    };
    QueueTask(BASE_NS::move(task));

    // We're loading all the buffers in one gather. This is probably fine as typical glTF files have just one binary
    // blob.
    (*(tasks_.begin() + firstTask))->state = ImporterTask::State::Gather;
    auto threadTask = IThreadPool::ITask::Ptr { new GatherThreadTask(*this, *(*(tasks_.begin() + firstTask))) };
    bufferTask_ = threadTask.get();
    ++pendingGatherTasks_[static_cast<uint32_t>(ImportPhase::BUFFERS)];
    gatherResults_[static_cast<uint32_t>(ImportPhase::BUFFERS)] = threadPool_->Push(BASE_NS::move(threadTask));
}

void GLTF2Importer::PrepareSamplerTasks()
{
    for (size_t i = 0; i < data_->samplers.size(); ++i) {
        auto task = make_unique<ImporterTask>();
        task->name = "Import sampler";
        task->phase = ImportPhase::SAMPLERS;
        task->import = [this, i]() -> bool {
            EntityReference entity;
            auto const& sampler = data_->samplers[i];
            if ((sampler->magFilter != FilterMode::LINEAR) || (sampler->minFilter != FilterMode::LINEAR) ||
                (sampler->wrapS != WrapMode::REPEAT) || (sampler->wrapT != WrapMode::REPEAT)) {
                GpuSamplerDesc desc;
                ConvertToCoreFilter(sampler->magFilter, desc.magFilter);
                ConvertToCoreFilter(sampler->minFilter, desc.minFilter, desc.mipMapMode);

                desc.minLod = 0.0f;
                desc.maxLod = 32.0f;

                desc.addressModeU = ConvertToCoreWrapMode(sampler->wrapS);
                desc.addressModeV = ConvertToCoreWrapMode(sampler->wrapT);
                desc.addressModeW = desc.addressModeU;

                entity = ecs_->GetEntityManager().CreateReferenceCounted();
                renderHandleManager_->Create(entity);
                string const name = data_->defaultResources + "_sampler_" + to_string(i);
                renderHandleManager_->Write(entity)->reference = gpuResourceManager_.GetOrCreate(name, desc);
            }
            result_.data.samplers.push_back(move(entity));

            return true;
        };

        QueueTask(move(task));
    }
}

void GLTF2Importer::QueueImage(size_t i, string&& uri, string&& name)
{
    struct ImageTaskData {
        GLTF2Importer* importer;
        size_t index;
        string uri;
        string name;
        refcnt_ptr<IRenderDataStoreDefaultStaging> staging;
        RenderHandleReference imageHandle;
    };

    constexpr const string_view RENDER_DATA_STORE_DEFAULT_STAGING = "RenderDataStoreDefaultStaging";

    auto staging = refcnt_ptr<IRenderDataStoreDefaultStaging>(
        renderContext_.GetRenderDataStoreManager().GetRenderDataStore(RENDER_DATA_STORE_DEFAULT_STAGING.data()));
    // Does not exist, which means it needs to be imported.
    auto task = make_unique<GatheredDataTask<ImageTaskData>>();
    task->data = ImageTaskData { this, i, move(uri), move(name), staging, {} };
    task->name = "Import image";
    task->phase = ImportPhase::IMAGES;
    task->gather = [t = task.get(), colorSpaceFlags = colorSpaceFlags_]() -> bool {
        GLTF2Importer* importer = t->data.importer;
        auto const& image = importer->data_->images[t->data.index];
        IImageLoaderManager::LoadResult result = GatherImageData(*image, *importer->data_,
            importer->engine_.GetFileManager(), importer->engine_.GetImageLoaderManager(), 0U, colorSpaceFlags);
        if (result.success) {
            t->data.imageHandle =
                ImportTexture(t->data.uri, move(result.image), *t->data.staging, importer->gpuResourceManager_);
        } else {
            CORE_LOG_W("Loading image '%s' failed: %s", image->uri.c_str(), result.error);
            t->errors += result.error;
            t->errors += '\n';
        }

        return true;
    };

    task->import = [t = task.get()]() mutable -> bool {
        if (t->data.imageHandle) {
            GLTF2Importer* importer = t->data.importer;
            auto imageEntity = importer->ecs_->GetEntityManager().CreateReferenceCounted();
            importer->renderHandleManager_->Create(imageEntity);
            importer->renderHandleManager_->Write(imageEntity)->reference = move(t->data.imageHandle);
            if (!t->data.uri.empty()) {
                importer->uriManager_->Create(imageEntity);
                importer->uriManager_->Write(imageEntity)->uri = move(t->data.uri);
            }
            if (!t->data.name.empty()) {
                importer->nameManager_->Create(imageEntity);
                importer->nameManager_->Write(imageEntity)->name = move(t->data.name);
            }

            importer->result_.data.images[t->data.index] = move(imageEntity);
        }

        return true;
    };

    task->finished = [t = task.get()]() {};

    QueueTask(move(task));
}

void GLTF2Importer::PrepareImageTasks()
{
    result_.data.images.resize(data_->images.size(), {});
    result_.data.textures.resize(data_->textures.size(), {});

    const bool skipUnusedResources = (flags_ & CORE_GLTF_IMPORT_RESOURCE_SKIP_UNUSED) != 0;

    vector<bool> imageLoadingRequred;
    imageLoadingRequred.resize(data_->images.size(), skipUnusedResources ? false : true);

    if (skipUnusedResources) {
        // Find image references from textures.
        ResolveReferencedImages(*data_, imageLoadingRequred);
    }

    // Tasks for image loading.
    for (size_t i = 0; i < data_->images.size(); ++i) {
        // Skip loading of this image if it is not referenced by textures.
        if (!imageLoadingRequred[i]) {
            continue;
        }

        string uri;
        string name = data_->defaultResources + "/images/" + to_string(i);

        auto const& image = data_->images[i];
        if (image->uri.empty() || GLTF2::IsDataURI(image->uri)) {
            // NOTE: Might need to figure out better way to reference embedded resources.
            uri = data_->filepath + "/" + name;
        } else {
            uri = data_->filepath + "/" + image->uri;
        }

        // See if this resource already exists.
        Entity imageEntity = LookupResourceByUri(uri, *uriManager_, *renderHandleManager_);
        if (EntityUtil::IsValid(imageEntity)) {
            // Already exists.
            result_.data.images[i] = ecs_->GetEntityManager().GetReferenceCounted(imageEntity);
            CORE_LOG_D("Resource already exists, skipping ('%s')", uri.c_str());
            continue;
        }

        QueueImage(i, move(uri), move(name));
    }

    // Tasks assigning textures to images.
    for (size_t i = 0; i < data_->textures.size(); ++i) {
        auto task = make_unique<ImporterTask>();
        task->name = "Import texture";
        task->phase = ImportPhase::TEXTURES;
        task->import = [this, i]() -> bool {
            const GLTF2::Texture& texture = *(data_->textures[i]);

            const size_t index = FindIndex(data_->images, texture.image);
            if (index != GLTF_INVALID_INDEX) {
                result_.data.textures[i] = result_.data.images[index];
            }

            return true;
        };
        QueueTask(move(task));
    }
}

void GLTF2Importer::PrepareImageBasedLightTasks()
{
#if defined(GLTF2_EXTENSION_EXT_LIGHTS_IMAGE_BASED)
    result_.data.specularRadianceCubemaps.resize(data_->imageBasedLights.size(), {});

    // Do nothing in case there are no image based lights.
    if (data_->imageBasedLights.empty()) {
        return;
    }

    for (size_t lightIndex = 0; lightIndex < data_->imageBasedLights.size(); ++lightIndex) {
        const auto& light = data_->imageBasedLights[lightIndex];

        // Create gather task that loads all cubemap faces for this light.
        auto task = make_unique<GatheredDataTask<RenderHandleReference>>();
        task->name = "Import specular radiance cubemaps";
        task->phase = ImportPhase::IMAGES;

        task->gather = [this, &light, t = task.get()]() -> bool {
            bool success = true;
            vector<IImageLoaderManager::LoadResult> mipLevels;
            // For all mip levels.
            for (const auto& mipLevel : light->specularImages) {
                // For all cube faces.
                for (const auto& cubeFace : mipLevel) {
                    if (cubeFace >= data_->images.size()) {
                        success = false;
                        break;
                    }
                    // Get image for this cube face.
                    auto& image = data_->images[cubeFace];
                    if (!image) {
                        success = false;
                        break;
                    }
                    // Load image.
                    auto loadResult =
                        GatherImageData(*image, *data_, engine_.GetFileManager(), engine_.GetImageLoaderManager(),
                            IImageLoaderManager::IMAGE_LOADER_FLIP_VERTICALLY_BIT, colorSpaceFlags_);
                    if (!loadResult.success) {
                        success = false;
                        CORE_LOG_W("Loading image '%s' failed: %s", image->uri.c_str(), loadResult.error);
                        break;
                    }

                    mipLevels.push_back(move(loadResult));
                }
            }
            if (!mipLevels.empty()) {
                t->data = CreateCubemapFromImages(light->specularImageSize, mipLevels, gpuResourceManager_);
            }
            return success;
        };

        task->import = [this, lightIndex, t = task.get()]() -> bool {
            // Import specular cubemap image if needed.
            if (t->data) {
                EntityReference imageEntity = ecs_->GetEntityManager().CreateReferenceCounted();
                renderHandleManager_->Create(imageEntity);
                renderHandleManager_->Write(imageEntity)->reference = move(t->data);
                result_.data.specularRadianceCubemaps[lightIndex] = move(imageEntity);
            }

            return true;
        };

        QueueTask(move(task));
    }
#endif
}

void GLTF2Importer::PrepareMaterialTasks()
{
    // Create EntityReferences for materials already at this stage. This allows assigning materials to meshes before
    // they are ready.
    const auto materialCount = data_->materials.size();
    result_.data.materials.reserve(materialCount);

    for (size_t i = 0; i < materialCount; ++i) {
        string uri;
        static constexpr string_view materialsPath = "/materials/";
        uri.reserve(data_->filepath.size() + data_->defaultResources.size() + materialsPath.size() + 2U);
        uri += data_->filepath;
        uri += '/';
        uri += data_->defaultResources;
        uri += materialsPath;
        uri += to_string(i);
        auto materialEntity = LookupResourceByUri(uri, *uriManager_, *materialManager_);
        if (EntityUtil::IsValid(materialEntity)) {
            CORE_LOG_D("Resource already exists, skipping ('%s')", uri.c_str());
        } else {
            materialEntity = ecs_->GetEntityManager().Create();
            if (!uri.empty()) {
                uriManager_->Create(materialEntity);
                uriManager_->Write(materialEntity)->uri = BASE_NS::move(uri);
            }
        }

        result_.data.materials.push_back(ecs_->GetEntityManager().GetReferenceCounted(materialEntity));
    }

    auto task = make_unique<ImporterTask>();
    task->name = "Import material";
    task->phase = ImportPhase::MATERIALS;
    task->import = [this]() -> bool {
        bool success = true;
        for (size_t i = 0; i < data_->materials.size(); ++i) {
            const Entity materialEntity = result_.data.materials[i];
            if (const auto materialComponentId = materialManager_->GetComponentId(materialEntity);
                materialComponentId != IComponentManager::INVALID_COMPONENT_ID) {
                // Material was already created
                continue;
            }
            // Does not exist, so needs to be imported.
            const auto& gltfMaterial = *data_->materials[i];
            if (!gltfMaterial.name.empty()) {
                nameManager_->Create(materialEntity);
                nameManager_->Write(materialEntity)->name = gltfMaterial.name;
            }
            materialManager_->Create(materialEntity);
            success = ImportMaterial(result_, *data_, gltfMaterial, materialEntity, *materialManager_,
                          gpuResourceManager_, dmShaderData_) &&
                      success;
        }

        return success;
    };

    QueueTask(move(task));
}

void GLTF2Importer::PrepareMeshTasks()
{
    result_.data.meshes.resize(data_->meshes.size(), {});
    if (flags_ & CORE_GLTF_IMPORT_RESOURCE_MESH_CPU_ACCESS) {
        meshBuilders_.resize(data_->meshes.size());
    }

    for (size_t i = 0; i < data_->meshes.size(); ++i) {
        string uri = data_->filepath + '/' + data_->defaultResources + "/meshes/" + to_string(i);
        const string_view name = data_->meshes[i]->name;

        // See if this resource already exists.
        const auto meshEntity = LookupResourceByUri(uri, *uriManager_, *meshManager_);
        if (EntityUtil::IsValid(meshEntity)) {
            // Already exists.
            result_.data.meshes[i] = ecs_->GetEntityManager().GetReferenceCounted(meshEntity);
            CORE_LOG_D("Resource already exists, skipping ('%s')", uri.c_str());
            continue;
        }

        auto task = make_unique<GatheredDataTask<GatherMeshDataResult>>();
        task->name = "Import mesh";
        task->phase = ImportPhase::MESHES;
        task->gather = [this, i, t = task.get()]() -> bool {
            const GLTF2::Mesh& mesh = *(data_->meshes[i]);

            // Gather mesh data.
            t->data = GatherMeshData(mesh, result_, flags_, *materialManager_, device_, engine_);
            t->errors = t->data.error;
            return t->data.success;
        };

        task->import = [this, i, uri = move(uri), name, t = task.get()]() mutable -> bool {
            if (!t->data.success) {
                return false;
            }
            // Import mesh.
            auto meshEntity = ImportMesh(*ecs_, t->data);
            if (!EntityUtil::IsValid(meshEntity)) {
                return false;
            }
            if (!uri.empty()) {
                uriManager_->Create(meshEntity);
                uriManager_->Write(meshEntity)->uri = move(uri);
            }
            if (!name.empty()) {
                nameManager_->Create(meshEntity);
                nameManager_->Write(meshEntity)->name = name;
            }

            result_.data.meshes[i] = ecs_->GetEntityManager().GetReferenceCounted(meshEntity);
            return true;
        };

        task->finished = [this, i, t = task.get()]() {
            if (flags_ & CORE_GLTF_IMPORT_RESOURCE_MESH_CPU_ACCESS) {
                meshBuilders_[i] = BASE_NS::move(t->data.meshBuilder);
            } else {
                t->data.meshBuilder.reset();
            }
        };

        QueueTask(move(task));
    }
}

template<>
GLTF2Importer::GatheredDataTask<GLTF2Importer::ComponentTaskData<AnimationInputComponent>>*
GLTF2Importer::PrepareAnimationInputTask(
    unordered_map<Accessor*, GatheredDataTask<ComponentTaskData<AnimationInputComponent>>*>& inputs,
    const AnimationTrack& track, IAnimationInputComponentManager* animationInputManager)
{
    GLTF2Importer::GatheredDataTask<GLTF2Importer::ComponentTaskData<AnimationInputComponent>>* result = nullptr;
    if (auto pos = inputs.find(track.sampler->input); pos == inputs.end()) {
        auto task = make_unique<GatheredDataTask<ComponentTaskData<AnimationInputComponent>>>();
        task->name = "Import animation input";
        task->phase = ImportPhase::ANIMATION_SAMPLERS;
        task->gather = [this, accessor = track.sampler->input, t = task.get()]() -> bool {
            return BuildAnimationInput(*data_, engine_.GetFileManager(), *accessor, t->data.component);
        };
        task->import = [em = &ecs_->GetEntityManager(), animationInputManager, t = task.get()]() -> bool {
            t->data.entity = em->CreateReferenceCounted();
            animationInputManager->Set(t->data.entity, t->data.component);
            return true;
        };
        inputs.insert({ track.sampler->input, task.get() });
        result = task.get();
        QueueTask(move(task));
    } else {
        result = pos->second;
    }
    return result;
}

template<>
GLTF2Importer::GatheredDataTask<GLTF2Importer::ComponentTaskData<AnimationOutputComponent>>*
GLTF2Importer::PrepareAnimationOutputTask(
    unordered_map<Accessor*, GatheredDataTask<ComponentTaskData<AnimationOutputComponent>>*>& outputs,
    const AnimationTrack& track, IAnimationOutputComponentManager* animationOutputManager)
{
    GatheredDataTask<ComponentTaskData<AnimationOutputComponent>>* result = nullptr;
    if (auto pos = outputs.find(track.sampler->output); pos == outputs.end()) {
        auto task = make_unique<GatheredDataTask<ComponentTaskData<AnimationOutputComponent>>>();
        task->name = "Import animation output";
        task->phase = ImportPhase::ANIMATION_SAMPLERS;
        task->gather = [this, accessor = track.sampler->output, path = track.channel.path, t = task.get()]() -> bool {
            return BuildAnimationOutput(*data_, engine_.GetFileManager(), *accessor, path, t->data.component);
        };
        task->import = [em = &ecs_->GetEntityManager(), animationOutputManager, t = task.get()]() -> bool {
            t->data.entity = em->CreateReferenceCounted();
            animationOutputManager->Set(t->data.entity, t->data.component);
            return true;
        };
        outputs.insert({ track.sampler->output, task.get() });
        result = task.get();
        QueueTask(move(task));
    } else {
        result = pos->second;
    }
    return result;
}

void GLTF2Importer::PrepareAnimationTasks()
{
    auto animationManager = GetManager<IAnimationComponentManager>(*ecs_);
    auto animationInputManager = GetManager<IAnimationInputComponentManager>(*ecs_);
    auto animationOutputManager = GetManager<IAnimationOutputComponentManager>(*ecs_);
    auto animationTrackManager = GetManager<IAnimationTrackComponentManager>(*ecs_);
    if (!animationManager || !animationInputManager || !animationOutputManager || !animationTrackManager) {
        return;
    }
    result_.data.animations.resize(data_->animations.size(), {});

    unordered_map<Accessor*, GatheredDataTask<ComponentTaskData<AnimationInputComponent>>*> inputs;
    unordered_map<Accessor*, GatheredDataTask<ComponentTaskData<AnimationOutputComponent>>*> outputs;
    for (size_t i = 0; i < data_->animations.size(); i++) {
        const string uri = data_->filepath + '/' + data_->defaultResources + "/animations/" + to_string(i);
        const string_view name = data_->animations[i]->name;

        // See if this resource already exists.
        const auto animationEntity = LookupResourceByUri(uri, *uriManager_, *animationManager);
        if (EntityUtil::IsValid(animationEntity)) {
            result_.data.animations[i] = ecs_->GetEntityManager().GetReferenceCounted(animationEntity);
            CORE_LOG_D("Resource already exists, skipping ('%s')", uri.c_str());
            continue;
        }
        vector<GatheredDataTask<ComponentTaskData<AnimationInputComponent>>*> inputResults;
        vector<GatheredDataTask<ComponentTaskData<AnimationOutputComponent>>*> outputResults;
        for (const auto& track : data_->animations[i]->tracks) {
            if (track.sampler && track.sampler->input && track.sampler->output) {
                inputResults.push_back(PrepareAnimationInputTask(inputs, track, animationInputManager));
                outputResults.push_back(PrepareAnimationOutputTask(outputs, track, animationOutputManager));
            }
        }

        auto task = make_unique<ImporterTask>();
        task->name = "Import animation";
        task->phase = ImportPhase::ANIMATIONS;
        task->import = AnimationTaskData { this, i, uri, name, animationManager, animationTrackManager,
            move(inputResults), move(outputResults) };
        task->finished = [t = task.get()]() { t->import = {}; };

        QueueTask(move(task));
    }
}

void GLTF2Importer::PrepareSkinTasks()
{
    auto* skinIbmManager = GetManager<ISkinIbmComponentManager>(*ecs_);
    if (!skinIbmManager) {
        return;
    }
    result_.data.skins.resize(data_->skins.size(), {});

    for (size_t i = 0; i < data_->skins.size(); i++) {
        string name = data_->defaultResources + "/skins/" + to_string(i);
        string uri = data_->filepath + '/' + name;

        // See if this resource already exists.
        const Entity skinIbmEntity = LookupResourceByUri(uri, *uriManager_, *skinIbmManager);
        if (EntityUtil::IsValid(skinIbmEntity)) {
            // Already exists.
            result_.data.skins[i] = ecs_->GetEntityManager().GetReferenceCounted(skinIbmEntity);
            CORE_LOG_D("Resource already exists, skipping ('%s')", uri.c_str());
            continue;
        }

        auto task = make_unique<GatheredDataTask<SkinIbmComponent>>();
        task->name = "Import skin";
        task->phase = ImportPhase::SKINS;
        task->gather = [this, i, t = task.get()]() -> bool {
            return BuildSkinIbmComponent(*(data_->skins[i]), t->data);
        };

        task->import = [this, i, uri = move(uri), name = move(name), t = task.get(), skinIbmManager]() mutable -> bool {
            if (!t->data.matrices.empty()) {
                auto skinIbmEntity = ecs_->GetEntityManager().CreateReferenceCounted();

                skinIbmManager->Create(skinIbmEntity);
                {
                    auto skinIbmHandle = skinIbmManager->Write(skinIbmEntity);
                    *skinIbmHandle = move(t->data);
                }

                uriManager_->Create(skinIbmEntity);
                uriManager_->Write(skinIbmEntity)->uri = move(uri);
                nameManager_->Create(skinIbmEntity);
                nameManager_->Write(skinIbmEntity)->name = move(name);
                result_.data.skins[i] = move(skinIbmEntity);
                return true;
            }

            return false;
        };

        task->finished = [t = task.get()]() { t->data = {}; };

        QueueTask(move(task));
    }
}

void GLTF2Importer::Destroy()
{
    delete this;
}

Gltf2SceneImporter::Gltf2SceneImporter(IEngine& engine, IRenderContext& renderContext, IEcs& ecs)
    : ecs_(ecs), graphicsContext_(GetInstance<IGraphicsContext>(
                     *renderContext.GetInterface<IClassRegister>(), UID_GRAPHICS_CONTEXT)),
      importer_(new GLTF2::GLTF2Importer(engine, renderContext, ecs))
{}

Gltf2SceneImporter::Gltf2SceneImporter(IEngine& engine, IRenderContext& renderContext, IEcs& ecs, IThreadPool& pool)
    : ecs_(ecs), graphicsContext_(GetInstance<IGraphicsContext>(
                     *renderContext.GetInterface<IClassRegister>(), UID_GRAPHICS_CONTEXT)),
      importer_(new GLTF2::GLTF2Importer(engine, renderContext, ecs, pool))
{}

void Gltf2SceneImporter::ImportResources(const ISceneData::Ptr& data, ResourceImportFlags flags)
{
    data_ = {};
    listener_ = nullptr;
    result_.error = 1;
    if (auto sceneData = data->GetInterface<SceneData>()) {
        if (auto* gltfData = sceneData->GetData()) {
            importer_->ImportGLTF(*gltfData, flags);
            UpdateResults();
            if (!result_.error) {
                data_ = data;
            }
        }
    }
}

void Gltf2SceneImporter::ImportResources(
    const ISceneData::Ptr& data, ResourceImportFlags flags, ISceneImporter::Listener* listener)
{
    data_ = {};
    listener_ = nullptr;

    if (auto sceneData = data->GetInterface<SceneData>()) {
        if (auto* gltfData = sceneData->GetData()) {
            listener_ = listener;
            data_ = data;
            importer_->ImportGLTFAsync(*gltfData, flags, this);
        }
    }
}

bool Gltf2SceneImporter::Execute(uint32_t timeBudget)
{
    if (importer_->Execute(timeBudget)) {
        UpdateResults();
        return true;
    }
    return false;
}

void Gltf2SceneImporter::Cancel()
{
    importer_->Cancel();
}

bool Gltf2SceneImporter::IsCompleted() const
{
    return importer_->IsCompleted();
}

const ISceneImporter::Result& Gltf2SceneImporter::GetResult() const
{
    return result_;
}

const MeshData& Gltf2SceneImporter::GetMeshData() const
{
    return meshData_;
}

Entity Gltf2SceneImporter::ImportScene(size_t sceneIndex)
{
    return ImportScene(sceneIndex, {}, SceneImportFlagBits::CORE_IMPORT_COMPONENT_FLAG_BITS_ALL);
}

Entity Gltf2SceneImporter::ImportScene(size_t sceneIndex, SceneImportFlags flags)
{
    return ImportScene(sceneIndex, {}, flags);
}

Entity Gltf2SceneImporter::ImportScene(size_t sceneIndex, Entity parentEntity)
{
    return ImportScene(sceneIndex, parentEntity, SceneImportFlagBits::CORE_IMPORT_COMPONENT_FLAG_BITS_ALL);
}

Entity Gltf2SceneImporter::ImportScene(size_t sceneIndex, Entity parentEntity, SceneImportFlags flags)
{
    if (importer_ && data_) {
        if (auto sceneData = data_->GetInterface<SceneData>()) {
            if (auto* gltfData = sceneData->GetData()) {
                auto& gltf = graphicsContext_->GetGltf();
                return gltf.ImportGltfScene(
                    sceneIndex, *gltfData, importer_->GetResult().data, ecs_, parentEntity, flags);
            }
        }
    }
    return {};
}

Entity Gltf2SceneImporter::ImportScene(size_t sceneIndex, uint32_t sceneId, SceneImportFlags flags)
{
    if (importer_ && data_) {
        if (auto sceneData = data_->GetInterface<SceneData>()) {
            if (auto* gltfData = sceneData->GetData()) {
                auto& gltf = graphicsContext_->GetGltf();
                return gltf.ImportGltfScene(sceneIndex, *gltfData, importer_->GetResult().data, ecs_, sceneId, flags);
            }
        }
    }
    return {};
}

void Gltf2SceneImporter::UpdateResults()
{
    const auto& result = importer_->GetResult();
    result_.error = result.success ? 0 : 1;
    result_.message = result.error;
    result_.data.samplers = result.data.samplers;
    result_.data.images = result.data.images;
    result_.data.textures = result.data.textures;
    result_.data.materials = result.data.materials;
    result_.data.meshes = result.data.meshes;
    result_.data.skins = result.data.skins;
    result_.data.animations = result.data.animations;
    result_.data.specularRadianceCubemaps = result.data.specularRadianceCubemaps;
    const auto& meshData = importer_->GetMeshData();
    meshData_.meshes.resize(meshData.meshes.size());
    for (size_t i = 0U; i < meshData.meshes.size(); ++i) {
        auto& dstMesh = meshData_.meshes[i];
        const auto& srcMesh = meshData.meshes[i];
        dstMesh.subMeshes.resize(srcMesh.subMeshes.size());
        std::transform(srcMesh.subMeshes.cbegin(), srcMesh.subMeshes.cend(), dstMesh.subMeshes.begin(),
            [](const GltfMeshData::SubMesh& gltfSubmesh) {
                MeshData::SubMesh submesh;
                submesh.indices = gltfSubmesh.indices;
                submesh.vertices = gltfSubmesh.vertices;
                submesh.indexBuffer = gltfSubmesh.indexBuffer;
                std::copy(std::begin(gltfSubmesh.attributeBuffers), std::end(gltfSubmesh.attributeBuffers),
                    std::begin(submesh.attributeBuffers));
                return submesh;
            });
    }
    meshData_.vertexInputDeclaration = meshData.vertexInputDeclaration;
}

// IInterface
const IInterface* Gltf2SceneImporter::GetInterface(const BASE_NS::Uid& uid) const
{
    if (uid == ISceneImporter::UID) {
        return static_cast<const ISceneImporter*>(this);
    }
    if (uid == IInterface::UID) {
        return static_cast<const IInterface*>(this);
    }
    return nullptr;
}

IInterface* Gltf2SceneImporter::GetInterface(const BASE_NS::Uid& uid)
{
    if (uid == ISceneImporter::UID) {
        return static_cast<ISceneImporter*>(this);
    }
    if (uid == IInterface::UID) {
        return static_cast<IInterface*>(this);
    }
    return nullptr;
}

void Gltf2SceneImporter::Ref()
{
    ++refcnt_;
}

void Gltf2SceneImporter::Unref()
{
    if (--refcnt_ == 0) {
        delete this;
    }
}

void Gltf2SceneImporter::OnImportStarted()
{
    if (listener_) {
        listener_->OnImportStarted();
    }
}

void Gltf2SceneImporter::OnImportFinished()
{
    if (listener_) {
        listener_->OnImportFinished();
    }
}

void Gltf2SceneImporter::OnImportProgressed(size_t taskIndex, size_t taskCount)
{
    if (listener_) {
        listener_->OnImportProgressed(taskIndex, taskCount);
    }
}
} // namespace GLTF2

CORE3D_END_NAMESPACE()