MeshAssimp.cpp

/*
 * Copyright (C) 2015 The Android Open Source Project
 *
 * 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.
 */

#define GL_NEAREST                        0x2600
#define GL_LINEAR                         0x2601
#define GL_NEAREST_MIPMAP_NEAREST         0x2700
#define GL_LINEAR_MIPMAP_NEAREST          0x2701
#define GL_NEAREST_MIPMAP_LINEAR          0x2702
#define GL_LINEAR_MIPMAP_LINEAR           0x2703
#define GL_TEXTURE_MAG_FILTER             0x2800
#define GL_TEXTURE_MIN_FILTER             0x2801
#define GL_TEXTURE_WRAP_S                 0x2802
#define GL_TEXTURE_WRAP_T                 0x2803

#include "MeshAssimp.h"

#include <stdlib.h>
#include <string.h>

#include <array>

#include <filament/Color.h>
#include <filament/VertexBuffer.h>
#include <filament/Engine.h>
#include <filament/IndexBuffer.h>
#include <filament/Material.h>
#include <filament/Renderer.h>
#include <filament/Scene.h>
#include <filament/RenderableManager.h>
#include <filament/TransformManager.h>

#include <math/norm.h>
#include <math/vec3.h>
#include <math/TVecHelpers.h>

#include <assimp/Importer.hpp>
#include <assimp/postprocess.h>
#include <assimp/cimport.h>
#include <assimp/scene.h>
#include <assimp/pbrmaterial.h>

#include <stb_image.h>

#include <filament/driver/DriverEnums.h>

#include "generated/resources/resources.h"

using namespace filament;
using namespace filamat;
using namespace filament::math;
using namespace utils;

enum class AlphaMode : uint8_t {
    OPAQUE,
    MASKED,
    TRANSPARENT
};

struct MaterialConfig {
    bool doubleSided = false;
    bool unlit = false;
    bool hasVertexColors = false;
    AlphaMode alphaMode = AlphaMode::OPAQUE;
    float maskThreshold = 0.5f;
    uint8_t baseColorUV = 0;
    uint8_t metallicRoughnessUV = 0;
    uint8_t emissiveUV = 0;
    uint8_t aoUV = 0;
    uint8_t normalUV = 0;

    uint8_t maxUVIndex() {
        return std::max({baseColorUV, metallicRoughnessUV, emissiveUV, aoUV, normalUV});
    }
};

void appendBooleanToBitMask(uint64_t &bitmask, bool b) {
    bitmask <<= 1;
    bitmask |= b;
}

uint64_t hashMaterialConfig(MaterialConfig config) {
    uint64_t bitmask = 0;
    memcpy(&bitmask, &config.maskThreshold, sizeof(config.maskThreshold));
    appendBooleanToBitMask(bitmask, config.doubleSided);
    appendBooleanToBitMask(bitmask, config.unlit);
    appendBooleanToBitMask(bitmask, config.hasVertexColors);
    appendBooleanToBitMask(bitmask, config.alphaMode == AlphaMode::OPAQUE);
    appendBooleanToBitMask(bitmask, config.alphaMode == AlphaMode::MASKED);
    appendBooleanToBitMask(bitmask, config.alphaMode == AlphaMode::TRANSPARENT);
    appendBooleanToBitMask(bitmask, config.baseColorUV == 0);
    appendBooleanToBitMask(bitmask, config.metallicRoughnessUV == 0);
    appendBooleanToBitMask(bitmask, config.emissiveUV == 0);
    appendBooleanToBitMask(bitmask, config.aoUV == 0);
    appendBooleanToBitMask(bitmask, config.normalUV == 0);
    return bitmask;
}

std::string shaderFromConfig(MaterialConfig config) {
    std::string shader = R"SHADER(
        void material(inout MaterialInputs material) {
    )SHADER";

    shader += "float2 normalUV = getUV" + std::to_string(config.normalUV) + "();\n";
    shader += "float2 baseColorUV = getUV" + std::to_string(config.baseColorUV) + "();\n";
    shader += "float2 metallicRoughnessUV = getUV" + std::to_string(config.metallicRoughnessUV) + "();\n";
    shader += "float2 aoUV = getUV" + std::to_string(config.aoUV) + "();\n";
    shader += "float2 emissiveUV = getUV" + std::to_string(config.emissiveUV) + "();\n";

    if (!config.unlit) {
        shader += R"SHADER(
            material.normal = texture(materialParams_normalMap, normalUV).xyz * 2.0 - 1.0;
            material.normal.y = -material.normal.y;
        )SHADER";
    }

    shader += R"SHADER(
        prepareMaterial(material);
        material.baseColor = texture(materialParams_baseColorMap, baseColorUV);
        material.baseColor *= materialParams.baseColorFactor;
    )SHADER";

    if (config.alphaMode == AlphaMode::TRANSPARENT) {
        shader += R"SHADER(
            material.baseColor.rgb *= material.baseColor.a;
        )SHADER";
    }

    if (!config.unlit) {
        shader += R"SHADER(
            vec4 metallicRoughness = texture(materialParams_metallicRoughnessMap, metallicRoughnessUV);
            material.roughness = materialParams.roughnessFactor * metallicRoughness.g;
            material.metallic = materialParams.metallicFactor * metallicRoughness.b;
            material.ambientOcclusion = texture(materialParams_aoMap, aoUV).r;
            material.emissive = texture(materialParams_emissiveMap, emissiveUV);
            material.emissive.rgb *= materialParams.emissiveFactor.rgb;
        )SHADER";
    }

    shader += "}\n";
    return shader;
}

Material* createMaterialFromConfig(Engine& engine, MaterialConfig config ) {
    std::string shader = shaderFromConfig(config);
    MaterialBuilder builder = MaterialBuilder()
            .name("material")
            .material(shader.c_str())
            .doubleSided(config.doubleSided)
            .require(VertexAttribute::UV0)
            .parameter(MaterialBuilder::SamplerType::SAMPLER_2D, "baseColorMap")
            .parameter(MaterialBuilder::UniformType::FLOAT4, "baseColorFactor")
            .parameter(MaterialBuilder::SamplerType::SAMPLER_2D, "metallicRoughnessMap")
            .parameter(MaterialBuilder::SamplerType::SAMPLER_2D, "aoMap")
            .parameter(MaterialBuilder::SamplerType::SAMPLER_2D, "emissiveMap")
            .parameter(MaterialBuilder::SamplerType::SAMPLER_2D, "normalMap")
            .parameter(MaterialBuilder::UniformType::FLOAT, "metallicFactor")
            .parameter(MaterialBuilder::UniformType::FLOAT, "roughnessFactor")
            .parameter(MaterialBuilder::UniformType::FLOAT, "normalScale")
            .parameter(MaterialBuilder::UniformType::FLOAT, "aoStrength")
            .parameter(MaterialBuilder::UniformType::FLOAT3, "emissiveFactor");

    if (config.maxUVIndex() > 0) {
        builder.require(VertexAttribute::UV1);
    }

    switch(config.alphaMode) {
        case AlphaMode::MASKED : builder.blending(MaterialBuilder::BlendingMode::MASKED);
            builder.maskThreshold(config.maskThreshold);
            break;
        case AlphaMode::TRANSPARENT : builder.blending(MaterialBuilder::BlendingMode::TRANSPARENT);
            break;
        default : builder.blending(MaterialBuilder::BlendingMode::OPAQUE);
    }

    builder.shading(config.unlit ? Shading::UNLIT : Shading::LIT);

    Package pkg = builder.build();
    return Material::Builder().package(pkg.getData(), pkg.getSize()).build(engine);
}

Texture* MeshAssimp::createOneByOneTexture(uint32_t pixel) {
    uint32_t *textureData = (uint32_t *) malloc(sizeof(uint32_t));
    *textureData = pixel;

    Texture *texturePtr = Texture::Builder()
            .width(uint32_t(1))
            .height(uint32_t(1))
            .levels(0xff)
            .format(driver::TextureFormat::RGBA8)
            .build(mEngine);

    Texture::PixelBufferDescriptor defaultNormalBuffer(textureData,
            size_t(1 * 1 * 4),
            Texture::Format::RGBA,
            Texture::Type::UBYTE,
            (driver::BufferDescriptor::Callback) &free);

    texturePtr->setImage(mEngine, 0, std::move(defaultNormalBuffer));
    texturePtr->generateMipmaps(mEngine);

    return texturePtr;
}

void getMinMaxUV(const aiScene *scene, const aiNode* node, float2 &minUV,
        float2 &maxUV, uint32_t uvIndex) {
    for (size_t i = 0; i < node->mNumMeshes; ++i) {
        const aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
        if (!mesh->HasTextureCoords(uvIndex)) {
            continue;
        }
        const float3* uv = reinterpret_cast<const float3*>(mesh->mTextureCoords[uvIndex]);
        const size_t numVertices = mesh->mNumVertices;
        const size_t numFaces = mesh->mNumFaces;
        if (numVertices == 0 || numFaces == 0) {
            continue;
        }
        if (uv) {
            for (size_t j = 0; j < numVertices; j++) {
                minUV = min(uv[j].xy, minUV);
                maxUV = max(uv[j].xy, maxUV);
            }
        }
    }
    for (size_t i = 0 ; i < node->mNumChildren ; ++i) {
        getMinMaxUV(scene, node->mChildren[i], minUV, maxUV, uvIndex);
    }
}

template<bool SNORMUVS>
static ushort2 convertUV(float2 uv) {
    if (SNORMUVS) {
        short2 uvshort(packSnorm16(uv));
        return bit_cast<ushort2>(uvshort);
    } else {
        half2 uvhalf(uv);
        return bit_cast<ushort2>(uvhalf);
    }
}

MeshAssimp::MeshAssimp(Engine& engine) : mEngine(engine) {
    mDefaultMap = createOneByOneTexture(0xffffffff);
    mDefaultNormalMap = createOneByOneTexture(0xffff8080);

    mDefaultColorMaterial = Material::Builder()
            .package(RESOURCES_AIDEFAULTMAT_DATA, RESOURCES_AIDEFAULTMAT_SIZE)
            .build(mEngine);

    mDefaultColorMaterial->setDefaultParameter("baseColor",   RgbType::LINEAR, float3{0.8});
    mDefaultColorMaterial->setDefaultParameter("metallic",    0.0f);
    mDefaultColorMaterial->setDefaultParameter("roughness",   0.4f);
    mDefaultColorMaterial->setDefaultParameter("reflectance", 0.5f);

    mDefaultTransparentColorMaterial = Material::Builder()
            .package(RESOURCES_AIDEFAULTTRANS_DATA, RESOURCES_AIDEFAULTTRANS_SIZE)
            .build(mEngine);

    mDefaultTransparentColorMaterial->setDefaultParameter("baseColor", RgbType::LINEAR, float3{0.8});
    mDefaultTransparentColorMaterial->setDefaultParameter("metallic",  0.0f);
    mDefaultTransparentColorMaterial->setDefaultParameter("roughness", 0.4f);
}

MeshAssimp::~MeshAssimp() {
    mEngine.destroy(mVertexBuffer);
    mEngine.destroy(mIndexBuffer);
    mEngine.destroy(mDefaultColorMaterial);
    mEngine.destroy(mDefaultTransparentColorMaterial);
    mEngine.destroy(mDefaultNormalMap);
    mEngine.destroy(mDefaultMap);

    for (auto& item : mGltfMaterialCache) {
        auto material = item.second;
        mEngine.destroy(material);
    }

    for (Entity renderable : mRenderables) {
        mEngine.destroy(renderable);
    }

    for (Texture* texture : mTextures) {
        mEngine.destroy(texture);
    }

    // destroy the Entities itself
    EntityManager::get().destroy(mRenderables.size(), mRenderables.data());
}

template<typename T>
struct State {
    std::vector<T> state;
    explicit State(std::vector<T>&& state) : state(state) { }
    static void free(void* buffer, size_t size, void* user) {
        auto* const that = static_cast<State<T>*>(user);
        delete that;
    }
    size_t size() const { return state.size() * sizeof(T); }
    T const * data() const { return state.data(); }
};

//TODO: Remove redundant method from sample_full_pbr
static void loadTexture(Engine *engine, const std::string &filePath, Texture **map,
        bool sRGB, bool hasAlpha) {

    if (!filePath.empty()) {
        Path path(filePath);
        if (path.exists()) {
            int w, h, n;
            int numChannels = hasAlpha ? 4 : 3;

            driver::TextureFormat inputFormat;
            if (sRGB) {
                inputFormat = hasAlpha ? driver::TextureFormat::SRGB8_A8 : driver::TextureFormat::SRGB8;
            } else {
                inputFormat = hasAlpha ? driver::TextureFormat::RGBA8 : driver::TextureFormat::RGB8;
            }

            Texture::Format outputFormat = hasAlpha ? Texture::Format::RGBA : Texture::Format::RGB;

            uint8_t *data = stbi_load(path.getAbsolutePath().c_str(), &w, &h, &n, numChannels);
            if (data != nullptr) {
                *map = Texture::Builder()
                        .width(uint32_t(w))
                        .height(uint32_t(h))
                        .levels(0xff)
                        .format(inputFormat)
                        .build(*engine);

                Texture::PixelBufferDescriptor buffer(data,
                        size_t(w * h * numChannels),
                        outputFormat,
                        Texture::Type::UBYTE,
                        (driver::BufferDescriptor::Callback) &stbi_image_free);

                (*map)->setImage(*engine, 0, std::move(buffer));
                (*map)->generateMipmaps(*engine);
            } else {
                std::cout << "The texture " << path << " could not be loaded" << std::endl;
            }
        } else {
            std::cout << "The texture " << path << " does not exist" << std::endl;
        }
    }
}

void loadEmbeddedTexture(Engine *engine, aiTexture *embeddedTexture, Texture **map,
        bool sRGB, bool hasAlpha) {

    int w, h, n;
    int numChannels = hasAlpha ? 4 : 3;

    driver::TextureFormat inputFormat;
    if (sRGB) {
        inputFormat = hasAlpha ? driver::TextureFormat::SRGB8_A8 : driver::TextureFormat::SRGB8;
    } else {
        inputFormat = hasAlpha ? driver::TextureFormat::RGBA8 : driver::TextureFormat::RGB8;
    }

    Texture::Format outputFormat = hasAlpha ? Texture::Format::RGBA : Texture::Format::RGB;

    uint8_t *data = stbi_load_from_memory((unsigned char *) embeddedTexture->pcData,
            embeddedTexture->mWidth, &w, &h, &n, numChannels);

    *map = Texture::Builder()
            .width(uint32_t(w))
            .height(uint32_t(h))
            .levels(0xff)
            .format(inputFormat)
            .build(*engine);

    Texture::PixelBufferDescriptor defaultBuffer(data,
            size_t(w * h * numChannels),
            outputFormat,
            Texture::Type::UBYTE,
            (driver::BufferDescriptor::Callback) &free);

    (*map)->setImage(*engine, 0, std::move(defaultBuffer));
    (*map)->generateMipmaps(*engine);
}

// Takes a texture filename and returns the index of the embedded texture,
// -1 if the texture is not embedded
int32_t getEmbeddedTextureId(const aiString& path) {
    const char *pathStr = path.C_Str();
    if (path.length >= 2 && pathStr[0] == '*') {
        for (int i = 1; i < path.length; i++) {
            if (!isdigit(pathStr[i])) {
                return -1;
            }
        }
        return std::atoi(pathStr + 1); // NOLINT
    }
    return -1;
}

TextureSampler::WrapMode aiToFilamentMapMode(aiTextureMapMode mapMode) {
    switch(mapMode) {
        case aiTextureMapMode_Clamp :
            return TextureSampler::WrapMode::CLAMP_TO_EDGE;
        case aiTextureMapMode_Mirror :
            return TextureSampler::WrapMode::MIRRORED_REPEAT;
        default:
            return TextureSampler::WrapMode::REPEAT;
    }
}

TextureSampler::MinFilter aiMinFilterToFilament(unsigned int aiMinFilter) {
    switch(aiMinFilter) {
        case GL_NEAREST: return TextureSampler::MinFilter::NEAREST;
        case GL_LINEAR: return TextureSampler::MinFilter::LINEAR;
        case GL_NEAREST_MIPMAP_NEAREST: return TextureSampler::MinFilter::NEAREST_MIPMAP_NEAREST;
        case GL_LINEAR_MIPMAP_NEAREST: return TextureSampler::MinFilter::LINEAR_MIPMAP_NEAREST;
        case GL_NEAREST_MIPMAP_LINEAR: return TextureSampler::MinFilter::NEAREST_MIPMAP_LINEAR;
        case GL_LINEAR_MIPMAP_LINEAR: return TextureSampler::MinFilter::LINEAR_MIPMAP_LINEAR;
        default: return TextureSampler::MinFilter::LINEAR_MIPMAP_LINEAR;
    }
}

TextureSampler::MagFilter aiMagFilterToFilament(unsigned int aiMagFilter) {
    switch(aiMagFilter) {
        case GL_NEAREST: return TextureSampler::MagFilter::NEAREST;
        default: return TextureSampler::MagFilter::LINEAR;
    }
}

// TODO: Change this to a member function (requires some alteration of cmakelsts.txt)
void setTextureFromPath(const aiScene *scene, Engine *engine,
        std::vector<filament::Texture*> textures, const aiString &textureFile,
        const std::string &materialName, const std::string &textureDirectory,
        aiTextureMapMode *mapMode, const char *parameterName,
        std::map<std::string, MaterialInstance *> &outMaterials,
        unsigned int aiMinFilterType=0, unsigned int aiMagFilterType=0) {

    TextureSampler::MinFilter minFilterType = aiMinFilterToFilament(aiMinFilterType);
    TextureSampler::MagFilter magFilterType = aiMagFilterToFilament(aiMagFilterType);

    TextureSampler sampler;
    if (mapMode) {
        sampler = TextureSampler(
                minFilterType,
                magFilterType,
                aiToFilamentMapMode(mapMode[0]),
                aiToFilamentMapMode(mapMode[1]),
                aiToFilamentMapMode(mapMode[2]));
    } else {
        sampler = TextureSampler(
                minFilterType,
                magFilterType,
                TextureSampler::WrapMode::REPEAT);
    }

    Texture* textureMap = nullptr;
    int32_t embeddedId = getEmbeddedTextureId(textureFile);

    // TODO: change this in refactor
    bool isSRGB = strcmp(parameterName, "baseColorMap") == 0 || strcmp(parameterName, "emissiveMap") == 0;
    bool hasAlpha = strcmp(parameterName, "baseColorMap") == 0;

    if (embeddedId != -1) {
        loadEmbeddedTexture(engine, scene->mTextures[embeddedId], &textureMap, isSRGB, hasAlpha);
    } else {
        loadTexture(engine, textureDirectory + textureFile.C_Str(), &textureMap, isSRGB, hasAlpha);
    }

    textures.push_back(textureMap);

    if (textureMap != nullptr) {
        outMaterials[materialName]->setParameter(parameterName, textureMap, sampler);
    }
}

template<typename VECTOR, typename INDEX>
Box computeTransformedAABB(VECTOR const* vertices, INDEX const* indices, size_t count,
        const mat4f& transform) noexcept {
    size_t stride = sizeof(VECTOR);
    filament::math::float3 bmin(std::numeric_limits<float>::max());
    filament::math::float3 bmax(std::numeric_limits<float>::lowest());
    for (size_t i = 0; i < count; ++i) {
        VECTOR const* p = reinterpret_cast<VECTOR const*>(
                (char const*) vertices + indices[i] * stride);
        const filament::math::float3 v(p->x, p->y, p->z);
        float3 tv = (transform * float4(v, 1.0f)).xyz;
        bmin = min(bmin, tv);
        bmax = max(bmax, tv);
    }
    return Box().set(bmin, bmax);
}

void MeshAssimp::addFromFile(const Path& path,
        std::map<std::string, MaterialInstance*>& materials, bool overrideMaterial) {

    Asset asset;
    asset.file = path;

    { // This scope to make sure we're not using std::move()'d objects later

        // TODO: if we had a way to allocate temporary buffers from the engine with a
        // "command buffer" lifetime, we wouldn't need to have to deal with freeing the
        // std::vectors here.

        //TODO: a lot of these method arguments should probably be class or global variables
        if (!setFromFile(asset, materials)) {
            return;
        }

        VertexBuffer::Builder vertexBufferBuilder = VertexBuffer::Builder()
                .vertexCount((uint32_t)asset.positions.size())
                .bufferCount(4)
                .attribute(VertexAttribute::POSITION,     0, VertexBuffer::AttributeType::HALF4)
                .attribute(VertexAttribute::TANGENTS,     1, VertexBuffer::AttributeType::SHORT4)
                .normalized(VertexAttribute::TANGENTS);

        if (asset.snormUV0) {
            vertexBufferBuilder.attribute(VertexAttribute::UV0, 2, VertexBuffer::AttributeType::SHORT2)
                .normalized(VertexAttribute::UV0);
        } else {
            vertexBufferBuilder.attribute(VertexAttribute::UV0, 2, VertexBuffer::AttributeType::HALF2);
        }

        if (asset.snormUV1) {
            vertexBufferBuilder.attribute(VertexAttribute::UV1, 3, VertexBuffer::AttributeType::SHORT2)
                    .normalized(VertexAttribute::UV1);
        } else {
            vertexBufferBuilder.attribute(VertexAttribute::UV1, 3, VertexBuffer::AttributeType::HALF2);
        }

        mVertexBuffer = vertexBufferBuilder.build(mEngine);

        auto ps = new State<half4>(std::move(asset.positions));
        auto ns = new State<short4>(std::move(asset.tangents));
        auto t0s = new State<ushort2>(std::move(asset.texCoords0));
        auto t1s = new State<ushort2>(std::move(asset.texCoords1));
        auto is = new State<uint32_t>(std::move(asset.indices));

        mVertexBuffer->setBufferAt(mEngine, 0,
                VertexBuffer::BufferDescriptor(ps->data(), ps->size(), State<half4>::free, ps));

        mVertexBuffer->setBufferAt(mEngine, 1,
                VertexBuffer::BufferDescriptor(ns->data(), ns->size(), State<short4>::free, ns));

        mVertexBuffer->setBufferAt(mEngine, 2,
                VertexBuffer::BufferDescriptor(t0s->data(), t0s->size(), State<ushort2>::free, t0s));

        mVertexBuffer->setBufferAt(mEngine, 3,
                VertexBuffer::BufferDescriptor(t1s->data(), t1s->size(), State<ushort2>::free, t1s));

        mIndexBuffer = IndexBuffer::Builder().indexCount(uint32_t(is->size())).build(mEngine);
        mIndexBuffer->setBuffer(mEngine,
                IndexBuffer::BufferDescriptor(is->data(), is->size(), State<uint32_t>::free, is));
    }

    // always add the DefaultMaterial (with its default parameters), so we don't pick-up
    // whatever defaults is used in mesh
    if (materials.find(AI_DEFAULT_MATERIAL_NAME) == materials.end()) {
        materials[AI_DEFAULT_MATERIAL_NAME] = mDefaultColorMaterial->createInstance();
    }

    size_t startIndex = mRenderables.size();
    mRenderables.resize(startIndex + asset.meshes.size());
    EntityManager::get().create(asset.meshes.size(), mRenderables.data() + startIndex);
    EntityManager::get().create(1, &rootEntity);

    TransformManager& tcm = mEngine.getTransformManager();
    //Add root instance
    tcm.create(rootEntity, TransformManager::Instance{}, mat4f());

    for (auto& mesh : asset.meshes) {
        RenderableManager::Builder builder(mesh.parts.size());
        builder.boundingBox(mesh.aabb);

        size_t partIndex = 0;
        for (auto& part : mesh.parts) {
            builder.geometry(partIndex, RenderableManager::PrimitiveType::TRIANGLES,
                    mVertexBuffer, mIndexBuffer, part.offset, part.count);

            if (overrideMaterial) {
                builder.material(partIndex, materials[AI_DEFAULT_MATERIAL_NAME]);
            } else {
                auto pos = materials.find(part.material);

                if (pos != materials.end()) {
                    builder.material(partIndex, pos->second);
                } else {
                    MaterialInstance* colorMaterial;
                    if (part.opacity < 1.0f) {
                        colorMaterial = mDefaultTransparentColorMaterial->createInstance();
                        colorMaterial->setParameter("baseColor", RgbaType::sRGB,
                                sRGBColorA { part.baseColor, part.opacity });
                    } else {
                        colorMaterial = mDefaultColorMaterial->createInstance();
                        colorMaterial->setParameter("baseColor", RgbType::sRGB, part.baseColor);
                        colorMaterial->setParameter("reflectance", part.reflectance);
                    }
                    colorMaterial->setParameter("metallic", part.metallic);
                    colorMaterial->setParameter("roughness", part.roughness);
                    builder.material(partIndex, colorMaterial);
                    materials[part.material] = colorMaterial;
                }
            }
            partIndex++;
        }

        const size_t meshIndex = &mesh - asset.meshes.data();
        Entity entity = mRenderables[startIndex + meshIndex];
        if (!mesh.parts.empty()) {
            builder.build(mEngine, entity);
        }
        auto pindex = asset.parents[meshIndex];
        TransformManager::Instance parent((pindex < 0) ?
                tcm.getInstance(rootEntity) : tcm.getInstance(mRenderables[pindex]));
        tcm.create(entity, parent, mesh.transform);
    }
}

using Assimp::Importer;

bool MeshAssimp::setFromFile(Asset& asset, std::map<std::string, MaterialInstance*>& outMaterials) {
    Importer importer;
    importer.SetPropertyInteger(AI_CONFIG_PP_SBP_REMOVE,
            aiPrimitiveType_LINE | aiPrimitiveType_POINT);
    importer.SetPropertyBool(AI_CONFIG_IMPORT_COLLADA_IGNORE_UP_DIRECTION, true);
    importer.SetPropertyBool(AI_CONFIG_PP_PTV_KEEP_HIERARCHY, true);

    aiScene const* scene = importer.ReadFile(asset.file,
            // normals and tangents
            aiProcess_GenSmoothNormals |
            aiProcess_CalcTangentSpace |
            // UV Coordinates
            aiProcess_GenUVCoords |
            // topology optimization
            aiProcess_FindInstances |
            aiProcess_OptimizeMeshes |
            aiProcess_JoinIdenticalVertices |
            // misc optimization
            aiProcess_ImproveCacheLocality |
            aiProcess_SortByPType |
            // we only support triangles
            aiProcess_Triangulate);

    scene = importer.ApplyPostProcessing(aiProcess_CalcTangentSpace);

    size_t index = importer.GetImporterIndex(asset.file.getExtension().c_str());
    const aiImporterDesc* importerDesc = importer.GetImporterInfo(index);
    bool isGLTF = importerDesc &&
            (!strncmp("glTF Importer",  importerDesc->mName, 13) ||
             !strncmp("glTF2 Importer", importerDesc->mName, 14));

    if (!scene) {
        std::cout << "No scene" << std::endl;
    }

    if (scene && !scene->mRootNode) {
        std::cout << "No root node" << std::endl;
    }

    // we could use those, but we want to keep the graph if any, for testing
    //      aiProcess_OptimizeGraph
    //      aiProcess_PreTransformVertices

    const std::function<void(aiNode const* node, size_t& totalVertexCount, size_t& totalIndexCount)>
            countVertices = [scene, &countVertices]
            (aiNode const* node, size_t& totalVertexCount, size_t& totalIndexCount) {
        for (size_t i = 0; i < node->mNumMeshes; i++) {
            aiMesh const *mesh = scene->mMeshes[node->mMeshes[i]];
            totalVertexCount += mesh->mNumVertices;

            const aiFace *faces = mesh->mFaces;
            const size_t numFaces = mesh->mNumFaces;
            totalIndexCount += numFaces * faces[0].mNumIndices;
        }

        for (size_t i = 0; i < node->mNumChildren; i++) {
            countVertices(node->mChildren[i], totalVertexCount, totalIndexCount);
        }
    };

    if (scene) {
        size_t deep = 0;
        size_t depth = 0;
        size_t matCount = 0;

        aiNode const* node = scene->mRootNode;

        size_t totalVertexCount = 0;
        size_t totalIndexCount = 0;

        countVertices(node, totalVertexCount, totalIndexCount);

        asset.positions.reserve(asset.positions.size() + totalVertexCount);
        asset.tangents.reserve(asset.tangents.size() + totalVertexCount);
        asset.texCoords0.reserve(asset.texCoords0.size() + totalVertexCount);
        asset.texCoords1.reserve(asset.texCoords1.size() + totalVertexCount);
        asset.indices.reserve(asset.indices.size() + totalIndexCount);

        float2 minUV0 = float2(std::numeric_limits<float>::max());
        float2 maxUV0 = float2(std::numeric_limits<float>::lowest());
        getMinMaxUV(scene, node, minUV0, maxUV0, 0);
        float2 minUV1 = float2(std::numeric_limits<float>::max());
        float2 maxUV1 = float2(std::numeric_limits<float>::lowest());
        getMinMaxUV(scene, node, minUV1, maxUV1, 1);

        asset.snormUV0 = minUV0.x >= -1.0f && minUV0.x <= 1.0f && maxUV0.x >= -1.0f && maxUV0.x <= 1.0f &&
                         minUV0.y >= -1.0f && minUV0.y <= 1.0f && maxUV0.y >= -1.0f && maxUV0.y <= 1.0f;

        asset.snormUV1 = minUV1.x >= -1.0f && minUV1.x <= 1.0f && maxUV1.x >= -1.0f && maxUV1.x <= 1.0f &&
                         minUV1.y >= -1.0f && minUV1.y <= 1.0f && maxUV1.y >= -1.0f && maxUV1.y <= 1.0f;

        if (asset.snormUV0) {
            if (asset.snormUV1) {
                processNode<true, true>(asset, outMaterials,
                                        scene, isGLTF, deep, matCount, node, -1, depth);
            } else {
                processNode<true, false>(asset, outMaterials,
                                        scene, isGLTF, deep, matCount, node, -1, depth);
            }
        } else {
            if (asset.snormUV1) {
                processNode<false, true>(asset, outMaterials,
                                        scene, isGLTF, deep, matCount, node, -1, depth);
            } else {
                processNode<false, false>(asset, outMaterials,
                                        scene, isGLTF, deep, matCount, node, -1, depth);
            }
        }

        // compute the aabb and find bounding box of entire model
        for (auto& mesh : asset.meshes) {
            mesh.aabb = RenderableManager::computeAABB(
                    asset.positions.data(),
                    asset.indices.data() + mesh.offset,
                    mesh.count);

            Box transformedAabb = computeTransformedAABB(
                    asset.positions.data(),
                    asset.indices.data() + mesh.offset,
                    mesh.count,
                    mesh.accTransform);

            float3 aabbMin = transformedAabb.getMin();
            float3 aabbMax = transformedAabb.getMax();

            if (!isinf(aabbMin.x) && !isinf(aabbMax.x)) {
                if (minBound.x > maxBound.x) {
                    minBound.x = aabbMin.x;
                    maxBound.x = aabbMax.x;
                } else {
                    minBound.x = fmin(minBound.x, aabbMin.x);
                    maxBound.x = fmax(maxBound.x, aabbMax.x);
                }
            }

            if (!isinf(aabbMin.y) && !isinf(aabbMax.y)) {
                if (minBound.y > maxBound.y) {
                    minBound.y = aabbMin.y;
                    maxBound.y = aabbMax.y;
                } else {
                    minBound.y = fmin(minBound.y, aabbMin.y);
                    maxBound.y = fmax(maxBound.y, aabbMax.y);
                }
            }

            if (!isinf(aabbMin.z) && !isinf(aabbMax.z)) {
                if (minBound.z > maxBound.z) {
                    minBound.z = aabbMin.z;
                    maxBound.z = aabbMax.z;
                } else {
                    minBound.z = fmin(minBound.z, aabbMin.z);
                    maxBound.z = fmax(maxBound.z, aabbMax.z);
                }
            }
        }

        return true;
    }
    return false;
}

template<bool SNORMUV0, bool SNORMUV1>
void MeshAssimp::processNode(Asset& asset,
        std::map<std::string,
        MaterialInstance *> &outMaterials,
        const aiScene *scene,
        bool isGLTF,
        size_t deep,
        size_t matCount,
        const aiNode *node,
        int parentIndex,
        size_t &depth) const {
    mat4f const& current = transpose(*reinterpret_cast<mat4f const*>(&node->mTransformation));

    size_t totalIndices = 0;
    asset.parents.push_back(parentIndex);
    asset.meshes.push_back(Mesh{});
    asset.meshes.back().offset = asset.indices.size();
    asset.meshes.back().transform = current;

    mat4f parentTransform = parentIndex >= 0 ? asset.meshes[parentIndex].accTransform : mat4f();
    asset.meshes.back().accTransform = parentTransform * current;

    for (size_t i = 0; i < node->mNumMeshes; i++) {
            aiMesh const* mesh = scene->mMeshes[node->mMeshes[i]];

            float3 const* positions  = reinterpret_cast<float3 const*>(mesh->mVertices);
            float3 const* tangents   = reinterpret_cast<float3 const*>(mesh->mTangents);
            float3 const* bitangents = reinterpret_cast<float3 const*>(mesh->mBitangents);
            float3 const* normals    = reinterpret_cast<float3 const*>(mesh->mNormals);
            float3 const* texCoords0 = reinterpret_cast<float3 const*>(mesh->mTextureCoords[0]);
            float3 const* texCoords1 = reinterpret_cast<float3 const*>(mesh->mTextureCoords[1]);

            const size_t numVertices = mesh->mNumVertices;

            if (numVertices > 0) {
                const aiFace* faces = mesh->mFaces;
                const size_t numFaces = mesh->mNumFaces;

                if (numFaces > 0) {
                    size_t indicesOffset = asset.positions.size();

                    for (size_t j = 0; j < numVertices; j++) {
                        float3 normal = normals[j];
                        float3 tangent;
                        float3 bitangent;

                        // Assimp always returns 3D tex coords but we only support 2D tex coords.
                        float2 texCoord0 = texCoords0 ? texCoords0[j].xy : float2{0.0};
                        float2 texCoord1 = texCoords1 ? texCoords1[j].xy : float2{0.0};
                        // If the tangent and bitangent don't exist, make arbitrary ones. This only
                        // occurs when the mesh is missing texture coordinates, because assimp
                        // computes tangents for us. (search up for aiProcess_CalcTangentSpace)
                        if (!tangents) {
                            bitangent = normalize(cross(normal, float3{1.0, 0.0, 0.0}));
                            tangent = normalize(cross(normal, bitangent));
                        } else {
                            // In assimp, the CalcTangentsProcess algorithm generates tangents in
                            // the +U direction and bitangents in the +V direction, but the glTF
                            // conformance suite (see NormalTangentTest) reveals that bitangents
                            // should be flipped.
                            tangent = tangents[j];
                            bitangent = -bitangents[j];
                        }

                        quatf q = filament::math::details::TMat33<float>::packTangentFrame({tangent, bitangent, normal});
                        asset.tangents.push_back(packSnorm16(q.xyzw));
                        asset.texCoords0.emplace_back(convertUV<SNORMUV0>(texCoord0));
                        asset.texCoords1.emplace_back(convertUV<SNORMUV1>(texCoord1));

                        asset.positions.emplace_back(positions[j], 1.0_h);
                    }

                    // Populate the index buffer. All faces are triangles at this point because we
                    // asked assimp to perform triangulation.
                    size_t indicesCount = numFaces * faces[0].mNumIndices;
                    size_t indexBufferOffset = asset.indices.size();
                    totalIndices += indicesCount;

                    for (size_t j = 0; j < numFaces; ++j) {
                        const aiFace& face = faces[j];
                        for (size_t k = 0; k < face.mNumIndices; ++k) {
                            asset.indices.push_back(uint32_t(face.mIndices[k] + indicesOffset));
                        }
                    }

                    uint32_t materialId = mesh->mMaterialIndex;
                    aiMaterial const* material = scene->mMaterials[materialId];

                    aiString name;
                    std::string materialName;

                    if (material->Get(AI_MATKEY_NAME, name) != AI_SUCCESS) {
                        if (isGLTF) {
                            while (outMaterials.find("_mat_" + std::to_string(matCount))
                                   != outMaterials.end()) {
                                matCount++;
                            }
                            materialName = "_mat_" + std::to_string(matCount);
                        } else {
                            materialName = AI_DEFAULT_MATERIAL_NAME;
                        }
                    } else {
                        materialName = name.C_Str();
                    }

                    if (isGLTF && outMaterials.find(materialName) == outMaterials.end()) {
                        std::string dirName = asset.file.getParent();
                        processGLTFMaterial(scene, material, materialName, dirName, outMaterials);
                    }

                    aiColor3D color;
                    sRGBColor baseColor{1.0f};
                    if (material->Get(AI_MATKEY_COLOR_DIFFUSE, color) == AI_SUCCESS) {
                        baseColor = *reinterpret_cast<sRGBColor*>(&color);
                    }

                    float opacity;
                    if (material->Get(AI_MATKEY_OPACITY, opacity) != AI_SUCCESS) {
                        opacity = 1.0f;
                    }
                    if (opacity <= 0.0f) opacity = 1.0f;

                    float shininess;
                    if (material->Get(AI_MATKEY_SHININESS, shininess) != AI_SUCCESS) {
                        shininess = 0.0f;
                    }

                    // convert shininess to roughness
                    float roughness = sqrt(2.0f / (shininess + 2.0f));

                    float metallic = 0.0f;
                    float reflectance = 0.5f;
                    if (material->Get(AI_MATKEY_COLOR_SPECULAR, color) == AI_SUCCESS) {
                        // if there's a non-grey specular color, assume a metallic surface
                        if (color.r != color.g && color.r != color.b) {
                            metallic = 1.0f;
                            baseColor = *reinterpret_cast<sRGBColor*>(&color);
                        } else {
                            if (baseColor.r == 0.0f && baseColor.g == 0.0f && baseColor.b == 0.0f) {
                                metallic = 1.0f;
                                baseColor = *reinterpret_cast<sRGBColor*>(&color);
                            } else {
                                // TODO: the conversion formula is correct
                                // reflectance = sqrtf(color.r / 0.16f);
                            }
                        }
                    }

                    asset.meshes.back().parts.push_back({
                            indexBufferOffset, indicesCount, materialName,
                            baseColor, opacity, metallic, roughness, reflectance
                    });
                }
            }
        }

    if (node->mNumMeshes > 0) {
        asset.meshes.back().count = totalIndices;
    }

    if (node->mNumChildren) {
        parentIndex = static_cast<int>(asset.meshes.size()) - 1;
        deep++;
        depth = std::max(deep, depth);
        for (size_t i = 0, c = node->mNumChildren; i < c; i++) {
            processNode<SNORMUV0, SNORMUV1>(asset, outMaterials, scene,
                                            isGLTF, deep, matCount, node->mChildren[i], parentIndex, depth);
        }
        deep--;
    }
}

void MeshAssimp::processGLTFMaterial(const aiScene* scene, const aiMaterial* material,
        const std::string& materialName, const std::string& dirName,
         std::map<std::string, MaterialInstance*>& outMaterials) const {

    aiString baseColorPath;
    aiString AOPath;
    aiString MRPath;
    aiString normalPath;
    aiString emissivePath;
    aiTextureMapMode mapMode[3];
    MaterialConfig matConfig;

    material->Get(AI_MATKEY_TWOSIDED, matConfig.doubleSided);
    material->Get(AI_MATKEY_GLTF_UNLIT, matConfig.unlit);

    aiString alphaMode;
    material->Get(AI_MATKEY_GLTF_ALPHAMODE, alphaMode);
    if (strcmp(alphaMode.C_Str(), "BLEND") == 0) {
        matConfig.alphaMode = AlphaMode::TRANSPARENT;
    } else if (strcmp(alphaMode.C_Str(), "MASK") == 0) {
        matConfig.alphaMode = AlphaMode::MASKED;
        float maskThreshold = 0.5;
        material->Get(AI_MATKEY_GLTF_ALPHACUTOFF, maskThreshold);
        matConfig.maskThreshold = maskThreshold;
    }

    material->Get(_AI_MATKEY_GLTF_TEXTURE_TEXCOORD_BASE, AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_BASE_COLOR_TEXTURE,
                  matConfig.baseColorUV);
    material->Get(_AI_MATKEY_GLTF_TEXTURE_TEXCOORD_BASE, AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLICROUGHNESS_TEXTURE,
                  matConfig.metallicRoughnessUV);
    material->Get(_AI_MATKEY_GLTF_TEXTURE_TEXCOORD_BASE, aiTextureType_LIGHTMAP, 0, matConfig.aoUV);
    material->Get(_AI_MATKEY_GLTF_TEXTURE_TEXCOORD_BASE, aiTextureType_NORMALS, 0, matConfig.normalUV);
    material->Get(_AI_MATKEY_GLTF_TEXTURE_TEXCOORD_BASE, aiTextureType_EMISSIVE, 0, matConfig.emissiveUV);

    uint64_t configHash = hashMaterialConfig(matConfig);

    if (mGltfMaterialCache.find(configHash) == mGltfMaterialCache.end()) {
        mGltfMaterialCache[configHash] = createMaterialFromConfig(mEngine, matConfig);
    }

    outMaterials[materialName] = mGltfMaterialCache[configHash]->createInstance();

    // TODO: is there a way to use the same material for multiple mask threshold values?
//    if (matConfig.alphaMode == masked) {
//        float maskThreshold = 0.5;
//        material->Get(AI_MATKEY_GLTF_ALPHACUTOFF, maskThreshold);
//        outMaterials[materialName]->setParameter("maskThreshold", maskThreshold);
//    }

    // Load property values for gltf files
    aiColor4D baseColorFactor;
    aiColor3D emissiveFactor;
    float metallicFactor = 1.0;
    float roughnessFactor = 1.0;

    // TODO: is occlusion strength available on Assimp now?

    // Load texture images for gltf files
    TextureSampler sampler(
            TextureSampler::MinFilter::LINEAR_MIPMAP_LINEAR,
            TextureSampler::MagFilter::LINEAR,
            TextureSampler::WrapMode::REPEAT);

    if (material->GetTexture(AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_BASE_COLOR_TEXTURE, &baseColorPath,
            nullptr, nullptr, nullptr, nullptr, mapMode) == AI_SUCCESS) {
        unsigned int minType = 0;
        unsigned int magType = 0;
        material->Get("$tex.mappingfiltermin", AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_BASE_COLOR_TEXTURE, minType);
        material->Get("$tex.mappingfiltermag", AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_BASE_COLOR_TEXTURE, magType);

        setTextureFromPath(scene, &mEngine, mTextures, baseColorPath,
                materialName, dirName, mapMode, "baseColorMap", outMaterials, minType, magType);
    } else {
        outMaterials[materialName]->setParameter("baseColorMap", mDefaultMap, sampler);
    }

    if (material->GetTexture(AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLICROUGHNESS_TEXTURE, &MRPath,
            nullptr, nullptr, nullptr, nullptr, mapMode) == AI_SUCCESS) {
        unsigned int minType = 0;
        unsigned int magType = 0;
        material->Get("$tex.mappingfiltermin", AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLICROUGHNESS_TEXTURE, minType);
        material->Get("$tex.mappingfiltermag", AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLICROUGHNESS_TEXTURE, magType);

        setTextureFromPath(scene, &mEngine, mTextures, MRPath, materialName,
                dirName, mapMode, "metallicRoughnessMap", outMaterials, minType, magType);
    } else {
        outMaterials[materialName]->setParameter("metallicRoughnessMap", mDefaultMap, sampler);
        outMaterials[materialName]->setParameter("metallicFactor", mDefaultMetallic);
        outMaterials[materialName]->setParameter("roughnessFactor", mDefaultRoughness);
    }

    if (material->GetTexture(aiTextureType_LIGHTMAP, 0, &AOPath, nullptr,
            nullptr, nullptr, nullptr, mapMode) == AI_SUCCESS) {
        unsigned int minType = 0;
        unsigned int magType = 0;
        material->Get("$tex.mappingfiltermin", aiTextureType_LIGHTMAP, 0, minType);
        material->Get("$tex.mappingfiltermag", aiTextureType_LIGHTMAP, 0, magType);
        setTextureFromPath(scene, &mEngine, mTextures, AOPath, materialName,
                dirName, mapMode, "aoMap", outMaterials, minType, magType);
    } else {
        outMaterials[materialName]->setParameter("aoMap", mDefaultMap, sampler);
    }

    if (material->GetTexture(aiTextureType_NORMALS, 0, &normalPath, nullptr,
            nullptr, nullptr, nullptr, mapMode) == AI_SUCCESS) {
        unsigned int minType = 0;
        unsigned int magType = 0;
        material->Get("$tex.mappingfiltermin", aiTextureType_NORMALS, 0, minType);
        material->Get("$tex.mappingfiltermag", aiTextureType_NORMALS, 0, magType);
        setTextureFromPath(scene, &mEngine, mTextures, normalPath, materialName,
                dirName, mapMode, "normalMap", outMaterials, minType, magType);
    } else {
        outMaterials[materialName]->setParameter("normalMap", mDefaultNormalMap, sampler);
    }

    if (material->GetTexture(aiTextureType_EMISSIVE, 0, &emissivePath, nullptr,
            nullptr, nullptr, nullptr, mapMode) == AI_SUCCESS) {
        unsigned int minType = 0;
        unsigned int magType = 0;
        material->Get("$tex.mappingfiltermin", aiTextureType_EMISSIVE, 0, minType);
        material->Get("$tex.mappingfiltermag", aiTextureType_EMISSIVE, 0, magType);
        setTextureFromPath(scene, &mEngine, mTextures, emissivePath, materialName,
                dirName, mapMode, "emissiveMap", outMaterials, minType, magType);
    }  else {
        outMaterials[materialName]->setParameter("emissiveMap", mDefaultMap, sampler);
        outMaterials[materialName]->setParameter("emissiveFactor", mDefaultEmissive);
    }

    //If the gltf has texture factors, override the default factor values
    if (material->Get(AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLIC_FACTOR, metallicFactor) == AI_SUCCESS) {
        outMaterials[materialName]->setParameter("metallicFactor", metallicFactor);
    }

    if (material->Get(AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_ROUGHNESS_FACTOR, roughnessFactor) == AI_SUCCESS) {
        outMaterials[materialName]->setParameter("roughnessFactor", roughnessFactor);
    }

    if (material->Get(AI_MATKEY_COLOR_EMISSIVE, emissiveFactor) == AI_SUCCESS) {
        sRGBColor emissiveFactorCast = *reinterpret_cast<sRGBColor*>(&emissiveFactor);
        outMaterials[materialName]->setParameter("emissiveFactor", emissiveFactorCast);
    }

    if (material->Get(AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_BASE_COLOR_FACTOR, baseColorFactor) == AI_SUCCESS) {
        sRGBColorA baseColorFactorCast = *reinterpret_cast<sRGBColorA*>(&baseColorFactor);
        outMaterials[materialName]->setParameter("baseColorFactor", baseColorFactorCast);
    }

    aiBool isSpecularGlossiness = false;
    if (material->Get(AI_MATKEY_GLTF_PBRSPECULARGLOSSINESS, isSpecularGlossiness) == AI_SUCCESS) {
        if (isSpecularGlossiness) {
            std::cout << "Warning: pbrSpecularGlossiness textures are not currently supported" << std::endl;
        }
    }
}